PROGRAMAÇÃO DE COMPUTADORES

Utilizando Linguagem C-ANSI

Versão 2.1 - 2007

SUMÁRIO
Sumário................................................................................................................................................2 Prefácio................................................................................................................................................6 1. Introdução ...................................................................................................................................7
1.1 Dados, Informações e Conhecimento.................................................................................................7 1.2 Lógica de Programação ......................................................................................................................7 1.3 Algoritmos e Estrutura de Dados.......................................................................................................8 1.4 Representação da Lógica ....................................................................................................................9 1.4.1 1.4.2 1.4.3 Diagrama de Fluxo........................................................................................................................10 Diagrama de Chappin ou Nassi-Schneiderman (NS).................................................................11 Português Estruturado .................................................................................................................12

1.5 Linguagem de Programação.............................................................................................................13 1.6 Compiladores e Interpretadores ......................................................................................................14 1.7 Paradigma de Programação: Programação Estruturada..............................................................14 1.8 Tipos de Dados...................................................................................................................................15 1.8.1 Tipo Inteiro....................................................................................................................................15

1.8.1.1 Sistema de Numeração Binária....................................................................................................16 1.8.1.2 Decimal Codificado em Binário ...................................................................................................17 1.8.2 1.8.3 1.8.4 1.8.5 Tipo Real........................................................................................................................................17 Tipo Caractere ..............................................................................................................................17 Tipo Lógico ....................................................................................................................................18 Observações Finais........................................................................................................................18

1.9 Exercícios ...........................................................................................................................................18

2.

A Linguagem C..........................................................................................................................20
2.1 Introdução..........................................................................................................................................20 2.2 Sintaxe da Linguagem C...................................................................................................................20 2.3 Identificadores ...................................................................................................................................21 2.4 Tipos de Dados...................................................................................................................................22 2.5 Variáveis.............................................................................................................................................22
2

2.5.1

Classe de Variáveis .......................................................................................................................22

2.6 Operadores.........................................................................................................................................23 2.6.1 2.6.2 2.6.3 2.6.4 2.6.5 2.6.6 2.6.7 Atribuição ......................................................................................................................................23 Aritméticos.....................................................................................................................................23 Incremento e Decremento ............................................................................................................23 Relacionais e Lógicos ....................................................................................................................24 Bit a Bit ..........................................................................................................................................24 Outros Operadores .......................................................................................................................25 Precedência....................................................................................................................................25

3.

Fluxo de Controle......................................................................................................................26
3.1 Comando de Seleção: if...else/switch................................................................................................26 3.2 Comando de Iteração: for/while/do...while .....................................................................................26 3.3 Comando de Desvio ...........................................................................................................................27 3.4 Outros Comandos..............................................................................................................................28

4.

Entrada e Saída .........................................................................................................................29
4.1 Exercícios ...........................................................................................................................................29

5.

Vetores e Matrizes .....................................................................................................................34
5.1 Exercícios ...........................................................................................................................................34

6.

Manipulação de “Strings” ........................................................................................................38
6.1 Exercícios ...........................................................................................................................................38

7.

Estruturas, Enumerações e Uniões ..........................................................................................40
7.1 Estruturas ..........................................................................................................................................40 7.2 Enumerações......................................................................................................................................41 7.3 Uniões .................................................................................................................................................41 7.4 Exercícios ...........................................................................................................................................42

8.

Ponteiros ....................................................................................................................................44
8.1 Exercícios ...........................................................................................................................................45

9.

Ponteiros, Vetores e Matrizes....................................................................................................46
9.1 Vetores e Matrizes de Ponteiros.......................................................................................................46
3

9.2 Exercícios ...........................................................................................................................................47

10. Funções......................................................................................................................................48
10.1 Ponteiros para Funções.....................................................................................................................48 10.2 Recursividade ....................................................................................................................................49 10.3 Função main.......................................................................................................................................50 10.4 Funções de String ..............................................................................................................................50 10.5 Funções Matemáticas ........................................................................................................................52 10.6 Funções de Hora e Data ....................................................................................................................55 10.7 Outras Funções..................................................................................................................................56 10.8 Exercícios ...........................................................................................................................................56

11. Alocação Dinâmica ...................................................................................................................59
11.1 Exercícios ...........................................................................................................................................60

12. Manipulação de Arquivos .........................................................................................................62
12.1 “Streams” e Arquivos .......................................................................................................................62 12.2 Tipos de Acesso..................................................................................................................................63 12.3 Funções Manipulação de Arquivos..................................................................................................63 12.4 Exercícios ...........................................................................................................................................66

13. Ordenação..................................................................................................................................68
13.1 Ordenação por Troca........................................................................................................................68 13.2 Ordenação por Seleção .....................................................................................................................69 13.3 Ordenação por Inserção ...................................................................................................................69 13.4 “Shell Sort” ........................................................................................................................................70 13.5 “Quicksort”........................................................................................................................................70

14. Estruturas de Dados ..................................................................................................................72
14.1 Pilhas ..................................................................................................................................................72 14.2 Filas.....................................................................................................................................................73 14.2.1 Filas Circulares .............................................................................................................................73 14.3 Listas Ligadas ....................................................................................................................................74 14.3.1 Listas Singularmente Ligadas......................................................................................................74
4

......................................................................................................77 14...................... APÊNDICE .................................................................................................83 16.3 Conversão entre Bases ......................1 Tabela ASCII ........84 16..........................................................3......82 16................................................................14................... Bibliografia...................................................................................................................2 Listas Duplamente Ligadas .....................81 15....83 16...........................................................................................................................................................................................................................................79 14......................4 Árvores Binárias.....................................................................................85 5 ....................................................................................2 Sistema Numérico.........5 Exercícios.............................

Prof. Francisco Yastami Nakamoto emaito: yastami@unifieo. Quaisquer dúvidas. Neste texto. os conceitos básicos da linguagem de programação C. críticas e sugestões serão bem vindas. de forma resumida.PREFÁCIO Esta apostila é destinada aos alunos das disciplinas de Programação de Computadores I e II do curso de Ciência da Computação.br Atualizado em: 01/02/2007 6 . Me. estruturas de dados e técnicas de programação baseado no livro texto e nas referências bibliográficas complementares. encontra-se.

O homem possui a capacidade de analisar as informações fornecidas pelos seus sentidos. INTRODUÇÃO 1.2 Lógica de Programação Todos os dias tomamos decisões das mais variadas possíveis. Informações e Conhecimento. compostas por uma seqüência de símbolos quantificados ou quantificáveis e puramente sintática. ou seja. A lógica faz parte de 7 . De acordo com Aristóteles (384-322 a. a idéia não existe antes da experiência vivida. Desta forma.1. O conhecimento é individual e único que criamos a partir da interação com outros seres humanos e o meio em que vivemos. o programador deve possuir o conhecimento do assunto em questão.). Dado um problema computacional. possui a capacidade de estudar e aplicar as possíveis soluções a este modelo. não existe nada na consciência que não tenha sido sentido pelos nossos cinco sentidos. Muitas destas decisões são resultado de um conjunto de ações que visam um resultado almejado. Todas as idéias e pensamentos entram em nossa consciência através da vivência através dos sentidos tornando-se conhecimento. enriquecendo o seu conhecimento através dos resultados obtidos. e implementá-lo no mundo real modificando o meio em que vive e. • Conhecimento é uma abstração pessoal de algum fato experimentado ou vivenciado por alguém. É a vivência do objeto do conhecimento e não uma interpretação pessoal. consequentemente. consequentemente. pode-se definir que: • Dados são entidades matemáticas. abstrair os problemas do mundo real e criar um modelo desse problema. ou seja. ou seja. • Informações são abstrações que não podem ser formalizadas através de uma teoria matemática ou lógica.C. Além disso. o conhecimento não é transmissível e sim um conjunto de informações. eficientes e elegantes. representadas por dados.1 Dados. ou seja. possui uma carga semântica que representa algo para alguém. dominar a sintaxe (dados) da linguagem de programação para elaborar a melhor semântica (informação) que represente no mundo computacional o conhecimento aplicado para a solução do problema. de acordo com o conhecimento anteriormente adquirido.C. os dados podem ser descritos através de representações formais.). programar é a arte de elaborar soluções computacionais eficazes. que descrevem o conhecimento. baseado na teoria das idéias de Platão (427347 a. 1.

c) Verificar todos os dados disponíveis para resolvê-lo. Um programa processa dados. o que é óbvio e certo. As estruturas de dados são organizações conceituais de informações. dado um problema de processamento de dados os passos realizados para a análise podem deve-se realizar uma análise seguindo os seguintes passos: a) Entender o problema proposto.3 Algoritmos e Estrutura de Dados Um computador é uma máquina que manipula dados. ou seja.a informação é a medida da redução da incerteza sobre um determinado estado de coisas por intermédio de uma mensagem. isto é. organizam as informações que representam uma situação real. porém. Os dígitos binários 0 e 1 são usados para representar os dois possíveis estados de determinado bit. Segundo a teoria da informação: “. b) Definir os objetivos a serem alcançados.. de acordo com a forma da organização. e) Dividir o problema em partes menores. isso é. Um algoritmo é descrito na literatura como: 8 . instruções que são executados por um computador. A lógica de programação em processamento de dados é a forma pela qual se representa em uma linguagem. imprevisibilidade ou valor-surpresa da mensagem. um nível de abstração na solução de problemas. pode comprometer a eficiência do algoritmo que manipula essa informação. o que é coerente. 1. sendo quantificada em bits de informação.” A unidade básica que representa a informação é o bit. disponibiliza a informação processada. Uma estrutura de dados permite apresentar uma forma mais compreensível de se observar as informações. oferecendo. se necessário. entra-se com os dados no programa que os processa e. ou seja. a estrutura de dados recebe as informações e o algoritmo processa-os. d) Estabelecer uma seqüência de ações para resolução do problema. assim. f) Rever os passos anteriores caso o objetivo não seja atingido. cujo valor compreende um entre duas possibilidades mutuamente exclusivas. Entende-se por lógico o que não permite questionamento. Neste sentido. A lógica de programação é diretamente influenciada pela forma como raciocinamos. Um programa é constituído de algoritmos e estrutura de dados.. ou símbolos que expressam essa linguagem.. a informação não deve ser confundida com o significado e apresenta-se como função direta do grau de originalidade. Um bit é uma contração das palavras binary digit ou dígitos binários..nossas decisões.

determina-se os passos seqüenciais para fazer o café: Encher água na chaleira. o casal está preparando café para servir aos convidados. observando-se a seqüência proposta. Adoçar o café. 1. Colocar café em pó no filtro. 2. ” considerando-se que: “ . ou seja.4 Representação da Lógica O algoritmo é a representação da resolução lógica de um problema de processamento de dados. Aguardar o processo de coar. Então. Se a água ferver.é uma seqüência finita de instruções.. Por exemplo. cada uma das quais possuem um significado claro e pode ser executada com uma quantidade finita de esforço ao longo de um tempo também finito..“ . então o objetivo principal é fazer o café. é possível prever passos essenciais que podem comprometer a resolução do problema.. ” Desta foram. acrescentar aos poucos a água no filtro... Encher água na chaleira.. Considerando-se as definições apresentadas anteriormente. 9 . certamente o objetivo será alcançado. que atinge um objetivo pré-estabelecido. é um conjunto seqüencial de ações executáveis ao longo de um tempo finito para obtenção de uma solução para um determinado tipo de problema. Colocar a chaleira para ferver. Sendo anfitrião do evento. Por exemplo: 1. Entretanto.. um encontro de amigos na residência do casal Leila e Francisco. executados num determinado período de tempo. um algoritmo é um conjunto finito instruções seqüenciais.uma série de passos organizados que descrevem um processo que se deseja seguir para dar solução a um problema específico. Preparar porta-filtro com filtro sobre o bule. mas para isso é preciso do café.. Colocar a chaleira para ferver. defini-se que os algoritmos são instruções que descrevem um padrão de comportamento expresso em termos de um conjunto finito de ações. Seguindo os passos apresentados. As seguintes perguntas devem ser respondidas: a) Qual é o problema? b) Qual é o objetivo? c) Como atingir o objetivo? O problema é servir o café aos convidados.

acrescentar aos poucos a água no filtro. Os símbolos para a representação gráfica são padronizados pela ANSI (figura 1. 4. porta-filtro. 5. determina-se o que é preciso para executar a seqüência. água.3. é realizado um detalhamento dos passos lógicos de um determinado processamento de forma gráfica. 6. ou seja. Desta forma. . A figura 1.4. Providenciar o café em pó. com os dados de entrada e a execução da seqüência. Aguardar o processo de coar.1 Diagrama de Fluxo Um diagrama de fluxo é uma representação gráfica de um algoritmo.Preparar porta-filtro com filtro sobre o bule. chaleira.1 . Do contrário: Voltar para o item 1. . Enquanto a chaleira está no fogo: . 1. Adoçar o café.Do contrário: Desligue o fogo. açúcar.1). Desta descrição é o algoritmo “fazer café”.Colocar café em pó no filtro. fogão.Se houver café em pó: .. Se não houver café em pó: Encerrar o preparo do café. o resultado é o café pronto. 10 . Indica início ou final do diagrama de fluxo Operação de atribuição e chamada ou retorno de subalgoritmo Conectores de páginas Operação de saída de dados em vídeo Operação de entrada de dados Arco de fluxo de dados Conector de fluxo Decisão Figura 1. tem-se: Pó de café. diagrama de Chapin ou português estruturado. Definido a seqüência de passos. filtro e bule Finalmente. Se a água ferver.Principais formas geométricas usadas em diagrama de fluxo. Um algoritmo é escrito utilizando uma linguagem de programação ou por meio de diagrama de fluxo.2 apresenta um exemplo de um programa.

apresentando-se uma visão hierárquica e estruturada da lógica do programa.4.3 .2 Diagrama de Chappin ou Nassi-Schneiderman (NS) O diagrama de Chapin (Nassi-Schneiderman) é um diagrama em que se retiram-se os arcos. Seqüência Seleção S <Comando> <?> N 1 2 <?> 3 4 Interação <Condição> <Condição> Figura 1.Os diagramas de Chapin (Nassi-Schneiderman). 1.3 apresenta os diagramas de Chapin. torna-se mais simples mostrá-lo com o diagrama de Chapin. seleção e repartição.2 .Exemplo de um diagrama de fluxo. bem como codificá-lo futuramente na conversão de código português estruturado ou pseudocódigos. A figura 1. Enquanto é difícil mostrar a recursividade no diagrama de fluxo. A grande vantagem de usar este tipo de diagrama é a representação das estruturas que tem um ponto de entrada e um ponto de saída e são compostas pelas estruturas básicas de controle de seqüência.Início Leia N1 e N2 M = (N1 + N2)/2 N M>=6 Imprima “Reprovado” S Imprima “Aprovado” Fim Figura 1. 11 .

3 Português Estruturado Esta forma de representação de algoritmos. encontra muita aceitação. A representação de um algoritmo na forma de pseudo-código é a seguinte: Algoritmo <nome_do_algoritmo> <declaração_de_variáveis> <subalgoritmos> Início <corpo_do_algoritmo> Fim. Início Leia N1.4. N Escreva “Aprovado” 1. também conhecida como “portugol” ou pseudo-código.5 apresenta um exemplo utilizando pseudo-código. por assemelhar-se bastante à forma em que os programas são escritos.4 apresenta um exemplo do tipo de diagrama de Chapin para o algoritmo de cálculo da média de um aluno.Exemplo de um diagrama Chapin (Nassi-Schneiderman). <nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de distinguílo dos demais. 12 . eventualmente. A figura 1. nos subalgoritmos. esta representação é suficientemente geral para permitir que a tradução de um algoritmo nela representado para uma linguagem de programação específica seja praticamente direta. De fato.A figura 1. <declaração_de_variáveis> consiste em uma porção opcional onde são declaradas as variáveis globais usadas no algoritmo principal e. <subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são definidos os subalgoritmos. Onde: Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo.4 . Início e Fim são respectivamente as palavras que delimitam o início e o término do conjunto de instruções do corpo do algoritmo. é bastante rica em detalhes e. N2 Média = (N1+N2)/2 Média >=7? S Escreva “Aprovado” Fim Figura 1.

Interpretadores fazem a interpretação de cada instrução do programa fonte executando-a dentro de um ambiente de programação.5 . Este conjunto de códigos possui regras de estruturação lógica e sintática própria.Algoritmo Média Declare N1.exe) podem ser executados fora dos ambientes de programação. A desvantagem é que em geral. Basic e AutoLISP por exemplo. Estas instruções são escritas através de um conjunto de códigos (símbolos e palavras). as linguagens de programação em dois grandes grupos: as linguagens de baixo nível e as de alto nível.Exemplo de um programa em pseudo-código. Estes programas executáveis (*. Um programa executável contém uma seqüência de instruções que podem ser executados pelo processador. tornando a programação mais difícil. Podemos dividir. Além disso. A linguagem de 13 . Dizemos que este conjunto de símbolos e regras formam uma linguagem de programação. isto é. um código gerado para um tipo de processador não serve para outro. São genericamente chamadas de linguagens Assembly. genericamente. basicamente soma e subtração e funções de leitura e armazenamento. A principal vantagem é que os programas são executados com maior velocidade de processamento ocupando menos espaço na memória. 1. Compiladores fazem a tradução de todas as instruções do programa fonte gerando um programa executável. N2. isto é. os programas em Assembly tem pouca portabilidade. Necessitam de compiladores ou interpretadores para gerar instruções do microprocessador. Linguagens de alto nível são linguagens voltadas para o ser humano. as instruções são bem primitivas. Neste formato executável. os códigos Assembly não são estruturados. são escritas usando as instruções do microprocessador do computador. N2 Média ← (N1+N2)/2 Se Média >=7 Então Escreva “Aprovado” Do contrário Escreva “Reprovado” Fim Figura 1.5 Linguagem de Programação Um programa de computador é um conjunto instruções que representam um algoritmo para a resolução de algum problema. Linguagens de baixo nível são linguagens voltadas para a máquina. Média Real Início Leia N1. Em geral utilizam sintaxe estruturada tornando seu código mais legível.

Softwares sofisticados significam grandes quantidades de linhas de código. Dentro deste contexto. a execução do programa depende da presença do interpretador na máquina. isto é. A principal vantagem é que os programas podem ser compiladas ou interpretadas tornando-os portáveis. surgiu-se no início dos anos 70 o conceito de modularização de código que permitiu desenvolver o paradigma de programação estruturada. GPSS (simulação).máquina é complexa para maioria das pessoas. A linguagem estruturada tem como característica principal a modularização do código e dos dados. a programação torna-se mais fácil por causa do maior ou menor grau de estruturação de suas linguagens. permitindo-se elevar o nível de abstração para o desenvolvimento de soluções mais eficientes. Em geral.6 executado. LISP (inteligência artificial) ou CLIPPER (banco de dados). isto é. 1. As linguagens de alto nível podem se distinguir quanto a sua aplicação em genéricas como C. acarretando como conseqüência um árduo trabalho na manutenção do código. Compiladores e Interpretadores Os termos compiladores e interpretadores referem-se à maneira como um programa é Um interpretador lê o código fonte do programa linha por vez e executando a instrução específica contida nesta linha. 1.7 Paradigma de Programação: Programação Estruturada Os recursos computacionais são compostos por hardware e software. As inovações em hardware permitem desenvolver softwares cada vez mais sofisticados. Pascal e Basic ou específicas como Fortran (cálculo matemático). A desvantagem é que em geral. possibilita a criação de sub-rotinas que empregam variáveis locais. Um compilador lê o programa inteiro e converte-o em um código objeto (código binário ou código de máquina). dessa forma usamos uma linguagem de um nível maior para escrever nossos programas. podem ser executados em varias plataformas com pouquíssimas modificações. que é uma tradução do código fonte do programa em uma forma que o computador possa executar diretamente. Os módulos ou sub-rotinas se interligam através de três mecanismos básicos: 14 . as rotinas geradas (em linguagem de maquina) são mais genéricas e portanto mais complexas e por isso são mais lentas e ocupam mais memória. Desta forma.

0. Os tipos de dados podem ser classificados em: Tipos Inteiros. Seleção: Especifica a possibilidade de selecionar o fluxo de execução do processamento baseado em ocorrências lógicas. Iteração: Permite a execução repetitiva de segmentos do programa. Tipos Caracteres. Excluindo-se destes qualquer número fracionário. tem-se os valores: 35. A função tem como objetivo conceitual realizar essas atividades adequadamente sem criar efeitos inesperados em outras partes do programa. os dados numéricos positivos ou negativos. Dados propriamente ditos. Estes dados podem ser classificados em: Instruções. Outra forma de estruturar e modularizar o código em linguagem C é pelo uso de blocos de código. 15 . Tipos Reais. Um bloco de código é um grupo de comandos que é tratado como uma unidade. 1. o principal componente estrutural é a função. Existe duas formas para representar números inteiros em binário: Sistema de numeração binária e Decimal codificado em binário. Como exemplo deste tipo de dado.1 Tipo Inteiro São caracterizados como tipos inteiros. a modularização do código permite que os programas possam: Compartilhar seções de códigos. Em linguagem C. que comandam o funcionamento da máquina e determinam a maneira como devem ser tratados os dados. que correspondem à porção das informações a serem processadas pelo computador. são sub-rotinas ou blocos de construção em que são realizadas as atividades pré-estabelecidas. Realizar facilmente manutenções no código.8 Tipos de Dados O trabalho realizado por um computador é basicamente manipular os dados contidos em sua memória. 1. Portanto.8.Seqüência: Implementa os passos de processamento necessários para descrever qualquer programa. isto é. Tipos Lógicos. 1024 entre outros. Facilitar a compreensão de programas através do número restrito sub-rotinas. -56.

(00100110)2=(38)10 (-38)10=(11011001)2 Figura 1.1 Sistema de Numeração Binária Neste sistema.8. Notação de complemento de dois: Um número negativo é representado somando-se 1 à representação de complemento de um de um número negativo (figura 1. cada posição de bit representa uma potência de 2. O inteiro é representado por uma soma de potências de 2.6 .Exemplo notação de complemento de dois. essa potência de 2 não será incluída na soma. Portanto. mas é reservado para o sinal do número. uma seqüência de bits de tamanho n pode representar um número inteiro não negativo entre 0 a 2(n-1). uma seqüência de bits de tamanho n pode representar um número inteiro entre -2(n-1)+1 a 2(n-1)-1. Portanto.Exemplo de notação de complemento de um. a potência de 2 representada por essa posição de bit será incluída na soma porém. se o valor for 0.7).1.8 .6 apresenta um exemplo. 21 + 22 + 25 = 38 A representação de inteiros negativos pode ser realizada baseado em dois métodos: Notação de complemento de um: Um número negativo é representado mudando-se cada bit em seu valor absoluto para a definição do bit oposto (figura 1. Portanto.7 . A figura 1. uma seqüência de bits de tamanho n pode representar um número inteiro entre -2(n-1) a 2(n-1)-1. Se o valor for 1 em determinada posição.8). Isto significa que o bit da extrema esquerda de um número não é mais usado para representar uma potência de 2. (-38)10=(11011001)2 11011001+1=11011010=(-38)10 Figura 1.1. 16 . 00100110 1ª posição 2ª posição 5ª posição Figura 1.Exemplo de sistema de numeração binária.

2 00100110 0010 0110 6 Figura 1. números e símbolos especiais. O método usado pelos computadores para representar números reais é a notação de ponto flutuante. 0. uma seqüência de bits pode ser usada para representar inteiros da seguinte forma: cada quatro bits representa um dígito decimal entre 0 e 9. Um número real representado por uma seqüência de 32 bits consiste de uma mantissa de 24 bits seguida por um expoente de 8 bits de base 10 (figura 1. ”Fone 574-9988”. chamada expoente. as seqüências contendo letras. Como exemplo deste tipo de dado. ” ”. Um número real é representado por uma mantissa vezes uma base elevada a uma potência de inteiro. Mantissa*baseexpoente 387. Desta forma.8. ”04387. uma seqüência representa o número formado por esses dígitos decimais na notação decimal convencional (figura 1. Um caractere é representado por 8 bits.2 Tipo Real São caracterizados como tipos reais. ”7” entre outros. 1.1. 52 Apto 1”.8.2. string. -56. Este tipo de dado também é conhecido como alfanumérico. ”Rua Alfa.9 . literal ou cadeia.987 entre outros. tem-se os valores: ”Programação”.8.030”.53=38753*10-2 1111 1111 0110 1000 1001 1111 1111 1110 Figura 1. 1.10 . 26 1.2 Decimal Codificado em Binário Neste sistema.3 Tipo Caractere São caracterizados como tipos caracteres.1.9). -45.10). os dados numéricos positivos e negativos e números fracionários.Exemplo decimal codificado em binário. 17 . Como exemplo deste tipo de dado. Uma seqüência de caracteres deve ser indicada entre aspas (” ”). tem-se os valores: 35.Representação de ponto flutuante.

Construa um algoritmo detalhado para trocar uma lâmpada. Construa um algoritmo para fazer o cálculo das suas despesas do mês.8. Dados o consumo em m3 de água dos três últimos meses. Construa um algoritmo para fazer uma ligação telefônica. pelo contrário. É a interpretação de um padrão de bits que dá o seu significado. qualquer significado pode ser atribuído a determinado padrão de bits. desde que seja feito com coerência. portanto. devido à contribuição do filósofo e matemático inglês George Boole na área da lógica matemática.1.4 Tipo Lógico São caracterizados como tipos lógicos os dados com valor verdadeiro e falso. 1011001 10000001 1010011 1010100 10000001 1001101 1001001 59 41 53 54 41 4D 49 89 65 83 84 65 77 73 Y A S T A M I Figura 1. sabendo-se que o preço por m3 é de R$ 3. 3.8. ela sintetiza os padrões utilizados na maioria das linguagens. 4. Calcular o número de dias existentes entre dois anos digitados pelo usuário.11 apresenta um exemplo. Por exemplo.Representação binária. 1.5 Observações Finais A classificação apresentada acima não se aplica a nenhuma linguagem de programação específica.50.11 . 6. diagrama de blocos e português estruturado para os seguintes exercícios: 1. hexadecimal e decimal de caracteres. 1. Outro aspecto a ser considerado é com relação à interpretação da informação. elaborar um algoritmo que calcule a estimativa da conta do próximo mês.9 Exercícios Construir algoritmos em português estruturado. Construa um algoritmo para comer uma barra de chocolate. a seqüência de bits 00100110 pode ser interpretada como o número 38 decimal. sendo que este tipo de dado poderá representar apenas um dos dois valores. Um método de interpretar um padrão de bits é freqüentemente chamado tipo de dado. Ele é chamado por alguns de tipo booleano. A figura 1. 5. 2. o número 26 hexadecimal ou o caractere ‘&’ no código ASCII. 18 .

subtração. Elabore um algoritmo que apresente a tabuada de multiplicação de um número fornecido pelo usuário. horas. Dado: Peso total do bolo. v = 10 + 5 * t 12. Ao final mostre os resultados. Calcular e mostrar o tempo em anos. Se o número for ímpar. 22. 10. elabore um algoritmo que calcule o valor que o cliente vai pagar. Dado o tipo do vinho e a quantidade comprada. 11. dado uma entrada t (s). o menor e a média. multiplicação e divisão. sabe-se que os vinhos tipo tinto custam R$ 8. sabendo-se que o preço por quilo de bolo é R$ 16. Um automóvel tem um consumo médio de 1 litro de gasolina para cada 16 km rodados. Elabore um algoritmo que calcule a hipotenusa de um triângulo retângulo dados as medidas dos dois catetos. 17. Elabore um algoritmo que calcule a soma de dez números pares fornecidos pelo usuário. Calcular o custo de um bolo de aniversário. Construa um algoritmo para somar e contar os números pares e ímpares de 30 números inteiros inseridos pelo usuário. A velocidade de um ponto material é regida pela equação apresentada a seguir. 16. 13. Construa um algoritmo para verificar em uma classe com 50 alunos quantos são do sexo feminino e masculino e. dias. quantos da classe toda são maiores que 18 anos. Construa um programa para ler e mostrar os dados digitados pelo usuário.7.00. emitir mensagem informando o usuário. Dados: sexo e idade dos alunos. 21. Em uma distribuidora. 14. Elabore um algoritmo que dado dois número fornecidos pelo usuário. Dado: Nome. 9. Emitir o resultado da soma. minutos e segundos de um ano digitado pelo usuário em relação ao ano atual. 18. Endereço e Telefone. fazer uma calculadora que pode realizar as seguintes operações: soma.00 e o rosê R$ 9. 15. 8. 19.00. 19 . Construa um algoritmo para o funcionamento de uma máquina de refrigerante. Construa um algoritmo para o funcionamento de uma máquina de lavar roupa. verifique qual é o maior. Calcule a quantidade de gasolina consumida. calcule a média aritmética. Dados: Distância percorrida. 20. Faça um algoritmo que calcule a velocidade v (m/s). Elabore um algoritmo que dados três números. Elabore um algoritmo que dados 10 números reais. meses.50. os de tipo branco R$ 8.

como rotinas para cálculos. as declarações. Outro aspecto a ser considerado. é que o padrão C ANSI estabelece 32 palavraschaves. Linkeditar o programa. As declarações expressam as partes do programa. O C foi criada no centro de pesquisas da Bell Laboratories em 1972 por Dennis Ritchie tendo como meta características de flexibilidade e portabilidade. Compilar o programa.2. Estas regras estão relacionadas com os tipos. A LINGUAGEM C 2. podendo dar significado a um identificador. A linguagem C é uma linguagem compilada. A geração do programa executável a partir do programa fonte obedece a uma seqüência de operações: Criar o programa. suportam o conceito de tipos de dados. A linguagem C é uma linguagem estruturada. genérica. A linguagem C é classificada como linguagem de alto nível somando-se as funcionalidades de linguagens de baixo nível. definir funções. Os tipos definem as propriedades dos dados manipulados em um programa. bytes e endereços e. ao mesmo tempo. e a chamada de funções de I/O são definidas nas expressões. Em 1983 a ANSI (American National Standards Institute) estabeleceu um padrão C ANSI. sendo obrigatória a sua declaração no 20 .1 Introdução A linguagem C é uma linguagem de alto nível. etc.2 Sintaxe da Linguagem C A sintaxe são regras detalhadas para um construção válida em linguagem C. permitem respectivamente escrever na tela e ler os dados a partir do teclado. impressão. alocar memória. O programador também pode definir novas funções em seus programas. definir conteúdo inicial. As funções especificam as ações que um programa executa quando roda. São palavras reservadas que são os comandos que compõem a linguagem C. que por sua vez são a união de uma ou mais funções executando cada qual o seu trabalho. As funções printf() e scanf() por exemplo. isto é. C permite a manipulação de bits. As linguagens de alto nível tipicamente possuem várias vezes esse número de palavras reservadas. Há funções básicas que estão definidas na biblioteca C. Todo programa C inicia sua execução chamando a função main(). As funções são as entidades operacionais básicas dos programas em C. as funções e as expressões. A determinação e alteração de valores. 2.

combinadas com a sintaxe formal de C. auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while Muitos compiladores acrescentam outras palavras-chaves para explorar melhor os recursos dos processadores e otimização da utilização da memória. Em C. Função main(): Variáveis locais e instruções do programa. isto é. printf(“Variável y=%d\n”. COUNT. Count. dependendo do compilador utilizado. protótipos e variáveis globais. nomes de variáveis. #include <stdlib. Count e COUNT são três identificadores distintos. funções. O padrão C ANSI determina que identificadores podem ter qualquer tamanho. rótulos. func(). declaração de constantes. A forma geral de um programa em C é: Componentes Iniciais: arquivos de cabeçalho. Por exemplo: int count. Tabela 2. 2. entre outros. números ou sublinhados. Cada instrução encerra com . printf(“Variável global x=%d\n”. } Implementação de Funções: Variáveis locais e definição das funções O padrão C ANSI determina 32 palavras-chave ou palavras reservadas que. int main(void) { int y=10. return(0).1). void func(void).h> #include <stdio.1 Lista de palavras-chave em C ANSI 1. x). letras maiúsculas e minúsculas são tratadas diferentemente. Logo. (ponto e vírgula) que faz parte do comando. Comentários no programa são colocados entre /* e */ não sendo considerados na compilação.3 Identificadores Identificadores são os nomes usados para referenciar objetos definidos pelos usuário. 1. y). count. foram a linguagem de programação C (tabela 2. considera-se apenas os 31 primeiros caracteres.programa principal. 21 .h> int x=20. Os identificadores não podem ser igual a uma palavra-chave de C ou nome de funções criadas pelo usuário ou que estão nas bibliotecas C. } void func(void) { printf(”Fim\n”). O primeiro caractere deve ser uma letra ou um sublinhado e os caracteres subseqüentes devem ser letras. porém em geral.

variáveis locais.2. na definição dos parâmetros das funções e fora de todas as funções. ponto flutuante de precisão dupla e sem valor: char. parâmetros formais e variáveis globais. O tipo void declara explicitamente uma função que não retorna valor algum ou cria ponteiros genéricos.647 0 a 4. Isto é conseguido através do uso de modificadores que alteram o significado de um tipo básico. ou seja. há cinco tipos básicos de dados: caractere.647 a 2.967. Exceto o tipo void.4 Tipos de Dados Em C.767 -2.483. respectivamente.147.483. Os modificadores podem ser: signed unsigned long short Tabela 2. não o seu tamanho em bytes (tabela 2.147.647 a 2.483. ponto flutuante.483. O padrão C ANSI estipula apenas a faixa mínima de cada tipo de dado.2 Tipos de dados definidos no padrão C ANSI.767 a 32.647 -2.767 0 a 65. int x.147.535 -32.1 Classe de Variáveis As variáveis podem ser declaradas em três lugares básicos: dentro de funções.295 Seis dígitos de precisão Dez dígitos de precisão Dez dígitos de precisão 2.767 -32. 2.147. O tamanho e a faixa desses tipos de dados variam de acordo com o tipo de processador e com a implementação do compilador em C. As variáveis devem ser declaradas da seguinte forma: <tipo> <nome_da_variavel>. double e void.2).5.767 a 32.5 Variáveis Variável é uma posição nomeada de memória utilizada para armazenar um valor que pode ser modificado pelo programa. inteiro. Por exemplo: 22 . int.294. float.767 a 32.767 a 32.767 0 a 65. Em algumas situações é necessário modificar um tipo básico para atender às necessidades de diversas situações. Tipo char unsigned char signed char int unsigned int signed int short int unsigned short int signed short int long int signed long int unsigned long int float double long double Tamanho (bits) 8 8 8 16 16 16 16 16 16 32 32 32 32 64 80 Faixa mínima -127 a 127 0 a 255 -127 a 127 -32. todos os demais tipos básicos podem ter vários modificadores precedendo-os.535 -32.

ou seja. 18. 16. #include <stdlib. 6. 7. printf(“g=%f”.6.h> float g. x = y = z = 0. 5. 11. 2. 17. 14.1. porém deve-se observar que poderá ocorrer uma possível perda de informação. return(0). 15. x = 10. 3. 4. é possível converter os tipos de forma automática.6.6 Operadores 2. g=soma10(x). 13.1 Atribuição O operador de atribuição pode ser utilizado dentro de qualquer expressão válida em C. é permitido atribuição do mesmo valor para muitas variáveis em uma única expressão: var1 = var2 = var3 = expressão.6. Esta conversão é conhecida como conversão de tipos. 9. 2. /*x é variável local*/ x=15. 19. A atribuição é válida para variáveis de tipos diferentes. 12. 20.2 Aritméticos + * / % Subtração Adição Multiplicação Divisão Módulo da divisão (resto) Os operadores aritméticos de C são: 2. /*g é variável global*/ float soma10(float c). 10. } 2.3 Incremento e Decremento -++ Decremento Incremento C inclui dois operadores que geralmente não são encontrados em outras linguagens: 23 . } float soma10(float c) { return(c+10). Em C. /*c é parâmetro formal*/ int main(void) { float x.g). 8.h> #include <stdio. A forma geral do operador de atribuição é: nome_da_variavel = expressão.

4 Relacionais e Lógicos O operador relacional refere-se à relação que os valores podem ter uns com os outros.5 Bit a Bit A linguagem C oferece um completo conjunto de operadores bit a bit.5 Operadores bit a bit. Operadores relacionais > Maior que >= Maior ou igual < Menor <= Menor ou igual == Igual != Diferente Operadores lógicos && AND || OR ! NOT É permitido combinar diversas operações em uma expressão. testar.4 Tabela verdade operadores lógicos. Em C. verdadeiro é qualquer valor diferente de zero. & | ^ ~ >> << AND OR XOR Complemento de um Deslocamento à esquerda Deslocamento à direita Tabela 2. A tabela 2. 2. Tabela 2.6.2. atribuir ou deslocar os bits efetivos em um byte (tabela 2. As expressões que usam operadores relacionais ou lógicos devolvem zero para falso e 1 para verdadeiro (tabela 2. isto é. Falso é zero. p 0 0 1 1 q 0 1 1 0 p&q 0 0 1 0 p|q 0 1 1 1 p^q 0 1 0 1 24 .6 Tabela verdade operadores bit a bit.5).3 Operadores relacionais e lógicos. Tabela 2.4 apresenta a tabela verdade dos operadores lógicos utilizando 1s e 0s.6. A tabela 2. O operador lógico refere-se à maneira como essas relações podem ser conectadas.3). por exemplo: 10>5&&!(10<9)||3<=4 p 0 0 1 1 q 0 1 1 0 p&&q 0 0 1 0 p||q 0 1 1 1 Verdadeiro !p 1 1 0 0 Tabela 2.6 apresenta a tabela verdade dos operadores bit a bit. A idéia de verdadeiro e falso é a base dos conceitos dos operadores lógicos e relacionais.

2.6.6

Outros Operadores
Tabela 2.7 Outros operadores.

?: & * sizeof(f) , . -> () []
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. #include <stdlib.h> #include <stdio.h>

Exp1 ? Exp2 : Exp3 “o endereço de” “o valor do endereço de” Retorna o tamanho em bytes de f Separa seqüência de operações Referência a elementos individuais de estruturas e uniões. Organizar precedência. Indexação de matrizes.

int main(void) { int x, y; printf(“Digite valor de x=”); scanf(&x); printf(“Digite valor de y=”); scanf(&y); print((x>y)? “x>y\n”:((x=y)? “x=y\n”: “x<y\n”) return(0); 13. }

2.6.7

Precedência
Tabela 2.8 Precedência dos operadores em C.

Maior

Menor

() ! * + << < == & ^ | && ?: =

[] -> ~ ++ -/ % >> <= > >= !=

*

&

sizeof

+=

-=

*=

25

3. FLUXO DE CONTROLE 3.1 Comando de Seleção: if...else/switch
1. #include <stdlib.h> #include <stdio.h> int main(void) { int x, y; printf(“Digite valor de x=”); scanf(“%d”,&x); printf(“Digite valor de y=”); scanf(“%d”,&y); if (x>y) printf(“x>y\n”); else { if (x=y) printf(“x=y\n”); else printf(“x<y\n”); } return(0); }

if (<condicao>) <expressão>; else <expressão>;

switch (<expressão>) { case constante1 : <seq. de comandos> break; case constante2 : <seq. de comandos> break; . . . default : <seq. de comandos> }
1. #include <stdlib.h> #include <stdio.h> int main(void) { int x; printf(“Digite valor de x=”); scanf(“%d”,&x); switch (x) { case 0: printf(“x=0\n”); break; case 1: printf(“x=1\n”); break; case 2: printf(“x=2\n”); break; case 3: printf(“x=3\n”); break; default: printf(“3<x<0\z”); } /*Fim switch*/ return(0); }

1. #include <stdlib.h> #include <stdio.h> int main(void) { char y; printf(“Escolha a, b, c ou d:”); y=getchar(); switch (x) { case ’a’: printf(“Escolhido a\n”); break; case ’b’: printf(“Escolhido b\n”); break; case ’c’: printf(“Escolhido c\n”); break; case ’d’: printf(“Escolhido d\n”); break; default: printf(“Escolha invalida\n”); } /*Fim switch*/ return(0); }

3.2

Comando de Iteração: for/while/do...while

for (<inicialização>, <condição>, <incremento>) <seq. de comando> while (<condição>) do { { <seq. de comando> <seq. de comando> } } while (<condição>);

26

1. #include <stdlib.h> #include <stdio.h> int main(void) { int i; for (i=0; i<10; i++) printf(“%d ”,i); return(0); }

1. #include <stdlib.h> #include <stdio.h> int main(void) { int i; i=0; while (i<10) { printf(“%d ”,i); } return(0); }

1. #include <stdlib.h> #include <stdio.h> int main(void) { int i; i=0; do { printf(“%d ”,i); } while (i<10); return(0); }

3.3
• • •

Comando de Desvio
Na linguagem C há quatro comandos que realizam um desvio incondicional:

return: É usado para retorno de uma função. A função será finalizada tão logo encontre o primeiro return; goto: É um comando de desvio que deve ser utilizado com precaução pois pode causar vazamento do fluxo de informação; break: Este comando possui duas formas de uso. A primeira é utilizada para terminar um case em um comando switch. A segunda forma é utilizada para forçar uma terminação imediata de um laço. O comando break provoca uma saída apenas do laço mais interno;

• •

exit: Este comando provoca uma terminação imediata do programa inteiro, forçando um retorno ao sistema operacional; continue: É um comando similar ao break porém em vez de forçar a terminação do laço, continue força que ocorra a próxima iteração do laço, pulando qualquer código intermediário. Para o laço for, continue faz com que o teste condicional e a porção de incremento do laço sejam executados. Para os laços while e do-while, o controle do programa passa para o teste condicional.

return (<expressão>);

goto <rótulo>; ... <rótulo>:

void exit(int codigo_de_retorno);

27

1. #include <stdlib.h> #include <stdio.h> int main(void) { int x; x=1; volta1: x++; if (x<50) { printf(”%d\n”,x); goto volta1; } return(0); }

1. #include <stdlib.h> #include <stdio.h> int main(void) { int x; for (x=0; x<50; x++) { printf(”%d\n”,x); if (x==25) break; } return(0); }

1. #include <stdlib.h> #include <stdio.h> int main(void) { char s[80], *str; int esp; printf("Digite uma string:"); gets(s); str=s; for (espaco=0; *str; str++) { if (*str!=' ') continue; esp++; } printf("%d espacos\n", esp); return (0); }

3.4
por exemplo:

Outros Comandos
Um comando de expressão é uma expressão válida em C seguida por ponto-e-vírgula,

soma(); /* Chamada de função */ a=sqrt(pow(b,2)+pow(c,2)); /* Comando de atribuição */ b+raiz(z); /* Comando válido, que não faz nada */ ; /* Comando vazio */

28

1) da entrada padrão (teclado). calcule e mostre a média ponderada dessas notas. ENTRADA E SAÍDA As funções printf() e scanf() realizam entrada e saída formatada.234. #include <stdlib.4. Faça um programa que receba três números inteiros.1 Comandos de formato para printf() e scanf().. y). As notas deverão estar na faixa entre 0 e 10.h> int main(void) { char c.3f\n’. printf(’%.. 2. c). Código %c %d %i %e %f %o %s %u %x %p 1. return(0). y). calcule e mostre a média aritmética dessas notas.). Faça um programa que receba três notas e seus respectivos pesos. Tabela 4. c=’d’.1f\n’. 3. Sua sintaxe é similar a printf(). printf(’%f\n’. float y. int x. printf(’%d\n’. isto é. . int printf(const char *str..2f\n’. x). y=19. } Formato Caractere Inteiros decimais com sinal Inteiros decimais com sinal Notação científica Ponto flutuante decimal Octal sem sinal String de caracteres Inteiros decimais sem sinal Hexadecimal sem sinal Apresenta um ponteiro 4. printf(’%c\n’. y).1 Exercícios 1. A expressão de controle pode conter caracteres que serão exibidos na tela e os códigos de formatação (tabela 3. int scanf(const char *str. .h> #include <stdio. O printf() é uma função de I/O. Cada argumento deve ser separado por vírgula. Faça um programa que receba três notas.1) que indicam o formato em que os argumentos devem ser impressos. Ela é o complemento de printf() e nos permite ler dados formatados (tabela 4. 29 . printf(’%.). x=c.. O scanf() também é uma função de I/O implementada em todos compiladores C. calcule e mostre a soma desses números. permite a leitura e a escrita de dados em vários formatos. printf(’%. y). que permite escrever no dispositivo padrão (tela).

o total de impostos descontados e o saldo atual.14) 7. Sabe-se que cada operação bancária de retirada paga CPMF de 0.38% e o saldo inicial da conta está zerado. Pedro comprou um saco de ração com peso em quilos. Faça um programa que calcule e mostre a área de um losango. Sabe-se que: Área = π * R2. Esse trabalhador emitiu dois cheques e agora deseja saber seu saldo atual. 8. c) a raiz quadrada do número digitado. 12. Calcule e mostre quanto restará de ração no saco após cinco dias. calcule e mostre o valor do rendimento e o valor total depois do rendimento. (π=3. d) O salário a receber eqüivale ao salário bruto menos o imposto. calcule e mostre: a) O número digitado ao quadrado. b) O salário bruto equivalente ao número de horas trabalhadas multiplicado pelo valor da hora trabalhada. b) O número digitado ao cubo. Faça um programa para calcular a área de um triângulo. medidas menores ou iguais a 0. calcule e mostre um elevado ao outro. 11. Faça um programa que calcule e mostre a tabuada de um número digitado pelo usuário. 15. Calcule e mostre o salário a receber seguindo as regras abaixo: a) A hora trabalhada vale a metade do salário mínimo. Esse programa não pode permitir a entrada de dados inválidos. Faça um programa que calcule e mostre a área de um triângulo. Sabe-se que: Área = ((base maior + base menor)*altura)/2. 9. Faça um programa que calcule e mostre a área de um círculo. Sabe-se que: Área = (base * altura)/2. ou seja. Sabe-se que: Área = (diagonal maior * diagonal menor)/2. Faça um programa que receba o valor de um depósito e o valor da taxa de juros.4. c) O imposto eqüivale a 3% do salário bruto. Faça um programa que receba um número positivo e maior que zero. 10. Pedro possui dois gatos para os quais fornece a quantidade de ração em gramas. Um trabalhador recebeu seu salário e o depositou em sua conta corrente bancária. 6. 30 . Faça um programa que calcule e mostre a área de um trapézio. Faça um programa que receba dois números maiores que zero. Faça um programa que receba o número de horas trabalhadas e o valor do salário mínimo. 5. 14. Elabore um programa que apresente os lançamentos. Faça um programa que receba o peso do saco de ração e a quantidade de ração fornecida para cada gato. 13.

b) O valor (R$) a ser pago por essa residência. Faça um programa que receba o preço de um produto.0 <= media <= 8. calcule e mostre a média ponderada e o conceito que segue a tabela abaixo. sem se preocupar com a altura do usuário. a avaliação semestral e a um exame final.0 5.16. sabendo-se que esse funcionário tem gratificação de 5% sobre o salário-base e paga imposto de 7% sobre o salário-base. considerando que a média no exame é 6. 21.0 7. Faça um programa que receba as três notas. Sabe-se que um quilowatt de energia custa um quinto do salário mínimo. 17. A média das três notas mencionadas anteriormente obedece aos pesos a seguir: NOTA Trabalho de laboratório Avaliação semestral Exame final PESO 2 3 5 22. Cada degrau de uma escada tem X de altura. MÉDIA PONDERADA 10. 25. calcule e mostre o salário a receber. calcule e mostre o novo preço sabendo-se que este sofreu um desconto de 10%. Calcule e mostre quantos degraus o usuário deverá subir para atingir seu objetivo.0 <= media MENSAGEM Reprovado Exame Aprovado 24.0< media <= 7.0. 19. calcule e mostre a nota que deverá ser tirada no exame para a aprovação. MÉDIA ARITMÉTICA 3.0 < media <= 6. 31 .0 7. 18. Faça um programa que receba o salário de um funcionário e o percentual de aumento. Calcule e mostre: a) O valor (R$) de cada quilowatt. calcule e mostre a médias aritmética e a mensagem que segue a tabela abaixo. 20. Faça um programa que receba três notas de um aluno.0 < media <= 5.0 <= media < 7. Faça um programa que receba o valor do salário mínimo e a quantidade de quilowatts consumida por uma residência.0 < media CONCEITO A B C D E 23.0 6.0 > media 3. Para alunos de exame.0 8. Faça um programa que receba o salário-base de um funcionário.. Faça um programa que receba essa altura e a altura que o usuário deseja alcançar subindo a escada. Faça um programa que receba dois números e mostre o maior. A nota final de um estudante é calculada a partir de três notas atribuídas respectivamente a um trabalho de laboratório. calcule e mostre o valor do aumento e o novo salário. Faça um programa que receba três números e mostre-os em ordem crescente. c) O valor (R$) a ser pago com desconto de 15%.

26.00 e R$ 1200.00 Mais que R$ 600. Se m for ímpar. todos inteiros e positivos. receba a opção do usuário e os dados necessários para executar cada operação. Faça um programa que receba o código correspondente ao cargo de um funcionário e seu salário atual e mostre o cargo. um de cada vez. Faça um programa que receba o salário de um funcionário.00 AUXÍLIO-ESCOLA R$ 150. Se m for par. Cada data deve ser fornecida por três valores inteiros. Faça um programa que receba três números inteiros em ordem crescente e um quarto número também inteiro que não siga esta regra. 32 .00 33. verifique quantos divisores possui. calcule e mostre o novo salário desse funcionário. o valor do aumento e seu novo salário. Mostre. 31.00 Entre R$ 500.00 R$ 100. SALÁRIO Até R$ 500. Elabore um programa que calcule as raízes de uma equação a segundo grau. acrescido de bonificação e de auxílio-escola.00 BONIFICAÇÃO 5% 12% Sem bonificação SALÁRIO Até R$ 600. f ( x) = a * x 2 + b * x + c f ( x) = 0 ∆ = b2 − 4 * a * c x1. 2 = −b± ∆ 2*a 29. Os cargos estão na tabela a seguir: CÓDIGO 1 2 3 4 5 CARGO Escriturário Secretário Caixa Gerente Diretor PERCENTUAL 50% 35% 20% 10% Não tem aumento 32. Faça um programa que receba um número inteiro e verifique se esse número é par ou ímpar. Menu de opções: 1: Somar dois números 2: Raiz quadrada de um número Digite a opção desejada: 30. Deve-se verificar se os três primeiros números estão em ordem crescente 27. em seguida. 28. onde o primeiro representa o dia.00 Acima de R$ 1200. o segundo o mês e o terceiro o ano. Faça um programa que leia um número indeterminado de valores para m. Mostre os cálculos realizados. os quatro números em ordem decrescente. Faça um programa que determine a data cronologicamente maior de duas datas fornecidas pelo usuário. Faça um programa que mostre o menu de opções a seguir. calcule a soma dos números inteiros de 1 até m (m não deve entrar nos cálculos).

. calcule e mostre a potência xy. Faça um programa que calcule a soma dos primeiros 50 números ímpares iniciando de 3. Faça um programa que leia o número de termos n e um valor positivo para x. + 3! 4! 5! 6! 7! 8! 9! n! 38. 39. Faça um programa que mostre os primeiros 50 números múltiplos de 3 iniciando de 3. 40. 41. Faça um programa que mostre os primeiros 50 números múltiplos de 2 iniciando de 2. calcule e mostre o valor da série a seguir: S = 1+ x 2 x3 x 4 x5 x 6 x 7 x8 x n−1 + + + + + + + . se n > 1 : n! = n * (n − 1) * (n − 2) * . Faça um programa que receba o ângulo de incidência dos raios solares... Faça um programa que leia dois valores inteiros e positivos: x e y. calcule e mostre o valor da série a seguir: S= x1 x 2 x 3 x 4 x 5 x 6 x 7 xn + + + + + + + . + 1! 2! 3! 4! 5! 6! 7! n! 36. * 3 * 2 *1 se n = 1 : n! = 1!= 1 se n = 0 : n! = 0!= 1 35. utilizando uma estrutura de repetição. Faça um programa que calcule a soma dos primeiros 50 números pares iniciando de 2.. 37. Faça um programa que monte os n primeiros termos da seqüência de Fibonacci. 33 .. Faça um programa que calcule o fatorial de um número inteiro fornecido pelo usuário.. 0 − 1 − 1 − 2 − 3 − 5 − 8 − 13 − 21 − 34 − 55 − . Faça um programa que leia o número de termos e um valor positivo para X... 43. 42.34. a altura de uma pessoa em metros e retorne o comprimento da sombra dessa pessoa conforme a figura abaixo.

j++) printf("%d ". ou vetores.h> int main(void) { int v[3][3]. j<3. for (i=0. ao último elemento. 3. 8. 12. } printf("\n"). Matrizes unidimensionais. 12. } for (i=0.h> #include <stdio. Matrizes multidimensionais são matrizes que possuem duas ou mais dimensões. Faça um programa que carregue uma matriz 2x2. 17.1 apresenta um exemplo de matriz unidimensional. Os vetores são.Exemplo notação de complemento de dois. 15.&v[i]). O acesso aos elementos é realizado mediante um índice ou pelo endereço.j). i<3. 13. 7.v[i][j]). listas de informações do mesmo tipo. 5. 3. Considerando-se que cada bloco armazena um único caractere. 6. i<10. 10. 14.v[i]). 19. return(0).h> #include <stdio. 20. } for (i=0.1 . 9. i++) { printf("\n").%d]=". a matriz no exemplo pode armazenar nove caracteres seqüenciais. VETORES E MATRIZES Matriz é uma coleção de variáveis do mesmo tipo referenciada por um nome comum. 15. for (i=0. scanf("%d". essencialmente. a coluna. 4. j. #include <stdlib. A figura 5.i. 17. 14. i. } 2. 8.v[i]). i<3. Figura 5. 6. 34 .1 Exercícios 1. 1. 16.i). j<3. i++) { printf("Endereco: %p. 16. 18. for (j=0. i++) { printf("Digite v[%d]=". 5. 11. 22. 9.h> int main(void) { int v[10]. 10. printf("v[%d]=%d\n".i . 2. 7. 4. } 5. O endereço mais baixo ou índice (0) corresponde ao primeiro elemento e o mais alto. i<10.5. A forma mais simples é a matriz bidimensional ou matriz linha-coluna. i++) for (j=0. #include <stdlib. que são armazenadas em posições contíguas da memória em uma ordem de índice. onde o primeiro índice indica a linha e o segundo. são matrizes que possuem apenas uma dimensão. As matrizes podem possuir várias dimensões. 11.&v[i][j]). i. ". 21. calcule e mostre uma matriz resultante que será a matriz digitada multiplicada pelo maior elemento da matriz. 13. 18. scanf("%d". } return(0). j++) { printf("Digite [%d.

Faça um programa que carregue uma matriz 4x7 com números reais. Ao final do relatório. Faça um programa que carregue uma matriz 6x4 com números inteiros. Faça um programa que carregue uma matriz 8x8 com números inteiros e mostre o maior e menor número com as respectivas posições (linha.2. Faça um programa que carregue uma matriz 10x20 com números inteiros e some cada uma das linhas. quantos alunos tiveram menor nota na prova 2 e quantos alunos tiveram menor nota na prova 3. mostre uma segunda matriz com os elementos diferentes de 30. A diagonal principal com a diagonal secundária. 10. em seguida. Na teoria dos sistemas define-se o elemento MINMAX de uma matriz como sendo o maior elemento da linha onde se encontra o menor elemento da matriz. Mostre um relatório com o número do aluno (número da linha) e a prova em que cada aluno obteve menor nota. calcule e mostre seu MINMAX e sua posição (linha e coluna). Faça um programa que carregue uma matriz 15x5 com números inteiros. armazenando o resultado das somas em um vetor. 3. calcule a média de todos os elementos e mostre a quantidade de números que são maiores ou iguais a média e sua respectiva posição. A coluna 4 com a coluna 10. calcule e mostre quantos elementos dessa matriz são maiores que 30 e. 5. 9. • • • • A linha 2 com a linha 8. A linha 5 com a coluna 10. Faça um programa que carregue uma matriz 8x8 com números reais. calcule e mostre quais os elementos da matriz que se repetem e quantas vezes cada um está repetido. Faça um programa que carregue uma matriz 8x8 com números inteiros e mostre a quantidade de números pares e ímpares. multiplique cada elemento da matriz pela soma da linha e mostre a matriz resultante. 7. 6. No lugar do número 30 da segunda matriz coloque o número zero. coluna). A seguir. 8. 4. 35 . 11. Faça um programa que carregue uma primeira matriz de ordem 4x5 e uma segunda matriz 5x2. Faça um programa que carregue uma matriz 10x10 com números inteiros. Faça um programa que carregue uma matriz 10x3 com as notas de dez alunos em três provas. armazenando-o em uma terceira matriz de ordem 4x2. calcule e mostre a matriz resultante do produto matricial das duas matrizes anteriores. mostre quantos alunos tiveram menor nota na prova 1. execute as trocas especificadas a seguir e mostre a matriz resultante.

Faça um programa que construa a tabela apresentada a seguir em uma matriz. 13. Elabore um programa que calcule a soma e a subtração de duas matrizes A e B. Emitir mensagem de erro se o código for inválido.12. onde D é a determinante da matriz de ordem 3. quantos números e em qual posição. Elabore um 36 . calcule a média aritmética dos elementos e mostre todos elementos maiores ou iguais à media e sua respectiva posição na matriz. A área do triângulo ABC é calculada de acordo com a fórmula abaixo. Dado uma entrada do usuário. Elabore um programa que calcule a determinante de uma matriz de ordem 3. Código 1 2 3 4 5 6 Mês Janeiro Fevereiro Março Abril Maio Junho Código 7 8 9 10 11 12 Mês Julho Agosto Setembro Outubro Novembro Dezembro 14. Faça um programa que leia um vetor de 20 números inteiros. a segunda coluna é formada pelas respectivas ordenadas e a terceira coluna é unitária. Considere o triângulo de vértices A(2. onde a primeira coluna é formada pelas abscissas dos pontos A. verifique se há esse número no vetor. 4) apresentado na figura a seguir. B e C. 16. 2) e C(3. 15. Elabore um programa que calcule a determinante de uma matriz de ordem 2.1). Dado um número digitado pelo usuário. Elabore um programa que calcule o produto de duas matrizes de ordem 3. exiba o mês do ano correspondente de acordo com a tabela. B(5. 3 2  1 9 3 + 2 2 + 9  5 11  5 − 9 + 3 1 = 5 + 3 − 9 + 1 = 8 − 8         17. Faça um programa que carregue uma matriz 5x5 de números reais. a b  D=  = a *d − b*c c d  18. x y D = a b  m n  z c  = x *b * p + y *c * m + z * a * n − z *b * m − x *c * n − y * a * p  p  19.

Elabore um programa que imprima os elementos da diagonal principal de qualquer matriz mxm. portanto. e é indicada por At (ou por At). 21.programa que receba as coordenadas dos vértices A. os elementos aij tais que i=j formam o que chamamos de diagonal principal da matriz. a matriz que se obtém trocando ordenadamente as linhas pelas colunas chama-se transposta de A. 37 . Dada uma matriz A(mxn). ATENÇÃO: Se a determinante D=0 então os três pontos não formam um triângulo. Numa matriz quadrada. são pontos de uma mesma reta!!! a x  D = bx  cx  a y 1  by 1 c y 1  1 S ABC = * D 2 20. Elabore um programa que receba uma matriz A(3x2) e crie a matriz At. B e C e calcule a área do triângulo.

12. por meio de ‘\0’. Faça um programa eu receba uma frase.lista[i]). 19. é comum o uso de matrizes de string. 14. Para criar uma matriz de strings. 2. 2. 8. #include <stdlib. Desta forma. 5. 38 . Em programação. calcule e mostre a quantidade de vogais. O seguinte exemplo apresenta o uso de uma matriz de string. MANIPULAÇÃO DE “STRINGS” String é uma cadeia de caracteres armazenadas uma matriz unidimensional (vetor) de caracteres finalizada pelo caractere nulo.h> #define MAX 10 #define LEN 31 char lista[MAX][LEN]. Faça um programa que receba uma palavra e coloque os caracteres em ordem crescente. troque todas as vogais por * e apresente o resultado 4. 10. 4. i++) printf(”%d . indica o fim da string. 9. ou seja. calcule e mostre a quantidade de caracteres. Faça um programa que receba uma palavra. i<MAX. } for (i=0. i+1. int main(void) { int i. } 6. Por exemplo. 11. 6. 18. 13. Faça um programa que receba uma palavra e inverta a ordem dos caracteres.h> #include <stdio. 15. Faça um programa que receba duas palavras e gere uma terceira que represente a combinação das duas anteriores. 20.1 Exercícios 1. 17. i++) { printf(”Digite um nome:”). Faça um programa que receba uma palavra. calcule e mostre a quantidade de consoantes da frase digitada. 16.6. 8. Faça um programa que receba uma frase. 7. 3. for (i=0. isto é. scanf(”%s”. 5. 3. Faça um programa que receba uma frase. utiliza-se uma matriz bidimensional de caracteres. Faça um programa que receba uma palavra. calcule e mostre a quantidade de vogais da frase digitada. return(0). deve-se declarar sempre o vetor com uma posição a mais para armazenar o caractere nulo. 1. lista[i]). a seguinte instrução declara um vetor nome que guarda uma string de 10 caracteres: char nome[11]. 9.%s\n”. i<MAX. 6. calcule e mostre a quantidade de vezes que o caractere a aparece. 7.

16.10. 39 . Faça um programa que receba uma frase. pesquise e apresente se encontrado o nome (em que posição do vetor). Faça um programa que receba uma frase. quais os caracteres existentes e a quantidade de cada caractere. Faça um programa que armazene 10 nomes. 13. Elabore um programa que receba uma frase e mostre a quantidade de palavras. 14 de setembro de 2001”. Caso a frase possua meses por extenso substitua-os pelo seu número correspondente. 12. Faça um programa que mostre a data do sistema nos seguintes formatos: “dia/mês/ano” e “São Paulo. calcule e mostre a quantidade de palavras da frase digitada. 15. Faça um programa que receba uma frase e mostre a quantidade total de cada caractere na frase. 14. 11. Faça um programa que armazene 10 nomes. Dado uma entrada do usuário.

#include <stdlib. 8. printf("Ola %s!\n". }*x. A declaração de variáveis do tipo estrutura pode ser realizada da seguinte maneira: struct cliente { char nome[41]. cliente *x. 15. scanf("%s". } Exemplo: 1. 7. <tipo> <variável_n>... 23. y.nome). Em C é declarada uma estrutura da seguinte maneira: struct <nome_da_struct> { <tipo> <variável_1>. }. . 4.h> #include <stdio. printf("Digite seu nome: "). struct cliente { char nome[41]. y. ESTRUTURAS.nome). printf("Ola %s!\n". printf("Ola %s!\n". A referência ou o acesso a um determinado membro da estrutura é dado por uma construção do tipo para variáveis e ponteiros: <nome_da_estrutura>. scanf("%s"..7. y. printf("Digite seu nome: "). int main(void) { x=&y. x->nome). 3. 20. 22. &x->nome). printf("Digite seu nome: "). }*x. sobrenome[41]. A palavra struct define uma declaração. z[5].nome). char sobrenome[41]. z[5].nome). scanf("%s". 10. 16. 5. 7. 12. }. z[0]. char sobrenome[41]. .. <tipo> <variável_2>. As variáveis são denominadas membros da estrutura. 18. Uniões. z[5]. struct { char char }.<membro> <nome_da_estrutura>-><membro> 14. 13. char sobrenome[41].h> struct cliente { char nome[41]. 11. 17. 19. Enumerações. 40 . struct cliente nome[41]. ENUMERAÇÕES E UNIÕES A linguagem C permite criar tipos de dados utilizando: • • • Estruturas.1 Estruturas Estrutura (structure) é um tipo de dado formado por um conjunto de variáveis referenciadas por um nome. y. return(0). 9. &y. 6. 2. &z[0]. 21. As estruturas permitem organizar os dados na memória e estabelecer um inter-relacionamento entre os mesmo de modo que facilite a manipulação dos dados e ofereça maior clareza aos programas. seguida do nome da estrutura e das respectivas variáveis delimitadas pelas chaves.

quinta. 16. case quarta: printf("quarta"). <tipo> <nome_da_variável_n>. 35. case terca: printf("terca"). sexta. 37. } O valor do primeiro elemento do conjunto enum é 0. 8. case sabado: printf("sabado"). No exemplo acima.h> enum dia_da_semana {Segunda. 13. 23. 24. scanf("%d". 9. 12. A definição e um exemplo é apresentada a seguir: union <identificador> { <tipo> <nome_da_vairável_01>. switch(dia) { case Segunda: printf("Segunda"). 11. terca. case quinta: printf("quinta"). 2. .h> #include <stdlib. 18. domingo}. case domingo: printf("domingo"). break. break. char c. 7. 36. } return(0). tanto o inteiro i como o caractere c compartilham a mesma porção de memória. 14. int main(void) { enum dia_da_semana dia. 26. 4. Porém i ocupa 2 bytes e c apenas 1 byte. 32. &dia).3 Uniões Uniões (union) é uma posição de memória que é compartilhada por duas ou mais variáveis diferentes. o mesmo endereço. break. 19. case sexta: printf("sexta").7. <tipo> <nome_da_vairável_02>. o compilador cria automaticamente uma variável grande o bastante para conter o maior 41 . 21. Considere o seguinte exemplo: 1. printf("Digite um numero de 0 a 6:").. 20. sabado. 7. 3. geralmente de tipos diferentes. 10. 27. 33.2 Enumerações Enumeração é um conjunto de constantes inteiras que especifica todos os valores legais que uma variável desse tipo pode ter. 28. break. 25. Quando uma union é declarada. break. 31.. 38. 15. default: printf("Fora da faixa!\n"). 34. break. }. }<variáveis union>. 17. 22. #include <stdio. union cliente { int i. 30. 29. break. 6. 5. quarta.

Este valor pode ser inteiro. 20. imprimir informações de um determinado cliente. W. prontuário. Este programa deve permitir a inserção de novos clientes. int main(void) { printf("Digite um inteiro:"). turma e data de nascimento. scanf("%f". &W.x).x). São necessários as seguintes informações do cliente: nome. 2. Elabore um programa que imprima as seguintes informações de 10 alunos de uma turma: nome. }W. 18.h> union tipoespecial { int x. } 7. 19.x). excluir um cliente do cadastro. estado civil.y). 14. 6. 17. rg. nome do cliente e saldo. 3. printf("O endereco da variavel y e: %p\n". 11. data de nascimento. Faça um programa de cadastro de clientes. &W. bairro. 15. pesquisar clientes e relatorio. W. float y. 7. printf("Voce digiou ponto flutuante %f\n". 21. 2.tipo de variável da union. numero. fax e celular. endereço. 16. telefone. 8. A utilização de union pode ajudar na produção de código portáveis e na utilização de conversões de tipos. printf("Voce digiou inteiro %d\n". printf("Digite um ponto flutuante:").4 Exercícios 1. 13. 5. turma e data de nascimento. Faça um programa que realize o cadastro de contas bancárias com as seguintes informações: número da conta. return(0). 4. 10. sobrenome. &W. 9. O relatorio deve 42 . estado. complemento. printf("O endereco da variavel x e: %p\n". elabore um programa que edite as informações de um determinado aluno escolhido pelo usuário. cidade. sexo. &W. O banco permitirá o cadastramento de apenas 15 contas e não pode haver mais de uma conta com o mesmo número.h> #include <stdlib. #include <stdio.y). 4. 5.y). cep. scanf("%d". Considerando os exercícios 1 e 2. editar dados de clientes cadastrados. 1. 12. prontuário. sobrenome. 3. sobrenome. Elabore um programa que armazene as seguintes informações de 10 alunos de uma turma: nome. Elabore um programa que leia um valor. ponto flutuante ou caractere. Crie o menu de opções a seguir: Menu de opcoes: Cadastrar Visualizar todas as contas de um determinado cliente Excluir a conta com o menor saldo Sair Opcao?: 6.

43 . quantos são solteiros(as). quantos são casados(as) . listar as cidades e a respectiva quantidade de clientes por cidade. diretor. quantos divorciados(as). categoria (comédia. São necessários as seguintes informações das fitas de vídeo: título. quantos são do sexo masculino e feminino. editar informações de fitas. ano. Faça um programa que gerencie uma locadora de vídeo. ação. pesquisar e imprimir informações de uma determinada fita. idioma. Este programa deve permitir a inserção de novas fitas. documentário ou infantil). drama.calcular a média de idade. descrição e quantidade disponível. com legenda ou sem legenda. 7.

. p++.. O mesmo ocorre com as demais iterações. A forma geral para declarar uma variável ponteiro é: <tipo> *<nome_do_ponteiro>. ao ser incrementado. É importante declarar o ponteiro corretamente pois de acordo com o tipo base pode ser realizado a aritmética de ponteiros. o ponteiro p é incrementado. 3.h> #include <stdlib. 11. armazenam a posição de uma outra variável na memória. isto é. 2. i++) { printf("O endereco armazenado e %p\n". 6. 14. Existem apenas duas operações aritméticas que podem ser usadas com ponteiros: adição e subtração. printf("p armazenou endereco %p\n". 5. v[5]. 13. 8. Após um ponteiro ser declarado o ponteiro possui um valor desconhecido. 9. 7. 16. um trecho de código executável ou ainda outro ponteiro. #include <stdio. for (i=0. float *p O tipo base do ponteiro define que tipo de variáveis o ponteiro pode apontar.p). } return 0. No primeira iteração do primeiro loop (for). Portanto é necessário atribuir um valor antes de utilizá-lo. p=&v[0]. soma-se 8 bytes. } O ponteiro p armazena inicialmente o primeiro byte do vetor v (Hexa 0063FDE4). as expressões envolvendo ponteiros concordam com as mesmas regras de qualquer outra expressão de C. O segundo loop (for) o ponteiro q é do tipo é double (8 bytes). 4.” Em geral. 10.. logo. Considerando-se o seguinte exemplo: 1. Um ponteiro pode armazenar a posição de uma variável de dado.” & = ”O endereço de.8. PONTEIROS Ponteiros são variáveis que contém um endereço de memória. o novo valor é o antigo mais 4 bytes (0063FDE4 + 4 = 0063FDE8).p). Existem dois operadores especiais para ponteiros: * = ”No endereço de. int i.h> int main(void) { float *p.. 15. 12. Sendo p um ponteiro para ponto flutuante (float). 44 . i<5.

7. apresente o conteúdo e o endereço de cada posição do vetor. r=&j. *r=j.. int j. Justifique cada uma delas. *s=*r. *s=k[5].8.. 3. s=k. 10. 8. 6. r=j. Elabore um programa que leia três números. 2. 45 . s=k[0]. *r. *s. Considere o trecho de código a seguir e responda se as seguintes expressões são construções válidas ou inválida. 2. . s=&k[0]. 1..1 Exercícios 1. 3. *r=&j. k[10]. 5. *s=k. calcule e mostre o maior e o menor número. Elabore um programa que um vetor de 10 números reais. Utilize um ponteiro.. 9. Utilize um ponteiro. . 4.

18. i. VETORES E MATRIZES Ponteiros e matrizes possuem uma estreita relação. } void mostra_erro(int num) { /*Inicia um vetor de ponteiros*/ char *erro[]= { "Erro zero\n". 6. "Erro quatro\n". printf("p armazenou endereco %p\n". de tamanho 10. 15. } 9. i. 25. "Erro dois\n". v[10]. } 46 . 7. #include <stdio. Considere o seguinte exemplo: 1. "Erro um\n". }. i++) mostra_erro(i). 6. int main(void) { int i. Em seguida é atribuído ao ponteiro p a posição 0 da variável vetor str. 8. 5. p+i). i++) printf("O endereco de p+%d e: %p\n". 16. 17.p). 10. 21. 23. 14. printf("%s".h> int main(void) { int *p. é: int *x[10]. 11.h> void mostra_erro(int num). Para x receber o conteúdo do vetor str posição 10. for (i=0. Exemplo: 1. x=*(p+10). 26. Por exemplo. i++) printf("O endereco de p[%d] e: %p\n". &p[i]). 19. 15. 13. "Erro tres\n". A declaração de uma matriz de ponteiros int. 5. 20. for(i=0. 4. 22. i<10. 9.1 Vetores e Matrizes de Ponteiros Ponteiros podem ser organizados em matrizes como qualquer outro tipo de dado. 12. 9. A linguagem C permite o acesso aos elementos de uma matriz de duas formas: aritmética de ponteiros e indexação de matrizes. 8. 10. 3. 14. printf("\n\n"). PONTEIROS. 13. as seguintes expressões são válidas: x=str[10]. 3. i<10. 4.h> #include <stdlib. 7. 24. é criado um vetor tipo char e um ponteiro para char.9. for (i=0. #include <stdlib. i<5. 2. p=&v[0].h> #include <stdio. return 0. return(0). i. 12. 11. erro[num]). 2. As duas expressões retornam o valor do décimo primeiro elemento do vetor str.

2 Exercícios 1. Utilize ponteiro. Escreva um programa que inverta a ordem dos caracteres de uma cadeia de caracteres. Faça um programa que carregue um vetor 10 de números reais. calcule a média aritmética dos elementos e mostre todos elementos maiores ou iguais à media e sua respectiva posição na vetor. Use ponteiros. 47 . 2.9.

float valor(float x) { x=x*x. 23.z.. Os argumentos podem ser passados de duas maneiras: • Chamada por Valor: Este método faz uma cópia do valor de um argumento no parâmetro formal. z=valor(y). printf(”y=%f. 2. 10. Os argumentos são chamados de parâmetros formais da função. y. z=%f\n”. 27. } 18. sendo que é privativo à função e não pode ser acessado por nenhum comando em uma outra função. a menos que utilize variáveis ou dados globais. Isto implica que quaisquer alterações no parâmetro afetam a variável usada para chamar a rotina. 7. um ponteiro de função pode ser usado para chamar uma função. printf(”Chamada por Referencia:\n”). Quando uma função é compilada. 6. z=valor(y). 21. Desta forma. return(x). 28. . float referencia(float *x). y. printf(”Chamada por valor:\n”). 5. z). z=%f\n”. quaisquer alterações feitas no parâmetro não têm nenhum efeito nas variáveis usadas para chamá-la. } float referencia(float *x) { x=x*x. int main(void) { float y=10. 17. z).. <tipo> <Var2>. A forma geral de uma função é: <Tipo_de_retorno> <nome_da_função>(<lista de parâmetros>) { <Corpo da Função> } OBS: <lista de parâmetros> = <tipo> <Var1>. 11. 22. portanto. • Chamada por Referência: Este método o endereço do argumento é copiado para o parâmetro formal.1 Ponteiros para Funções As variáveis possuem uma posição física na memória assim como o próprio código executável do programa. 3. 19. printf(”y=%f. 1. 13. 20. 25. 24. São variáveis locais que pertencem à função e são criadas na entrada e destruídas na saída. 9. não pode afetar ou ser afetado por outras partes do programa.. 16. exceto por meio de uma chamada de função.h> #include <stdlib. 14.h> float valor(float x). 12. Quando é feita 48 .10. } 10. 26. FUNÇÕES Funções são blocos de construção em C. portanto. return(0). 4. 8. #include <stdio. O endereço de uma função é o ponto de entrada da função. <tipo> <Varn> Cada função é um bloco discreto de código. return(x). 15. o código fonte é transformado em código objeto e um ponto de entrada é estabelecido. O escopo da função é a porção de código e dados (variáveis locais) que constitui o corpo da função que é oculto do resto do programa.

i<5. 5. A recursividade talvez seja a mais importante vantagem das funções em C. 35. A principal vantagem das funções recursivas é que pode ser utilizadas para criar versões mais claras e simples de vários algoritmos.uma chamada de função. 42. 29. "Primeiro Erro quatro\n". void (*p)(int). 33. "Segundo Erro quatro\n". 12. return 0. A recursão é o processo é o processo de definir algo em termos de si mesmo. funções podem chamar a si mesmas. for (t=1. 7. printf("%s". da funcao: %p\n". Não existe ganho de velocidade ou espaço de memória significativo com o uso de funções recursivas. 14.. 25. int main(void) { int i. 41. answer=1. i<5. i++) p(i). é efetuada uma chamada em linguagem de máquina para o endereço desse ponto de entrada. for(i=0. 36. printf("End. 39. "Segundo Erro dois\n". isto é. 40. "Primeiro Erro tres\n". 45. Por exemplo: O cálculo do fatorial de um número é definido pela seguinte expressão: n! = n * ( n − 1) * ( n − 2) * . enquanto o programa está sendo executado. 43. p). 22. return(answer). "Primeiro Erro um\n". Uma propriedade dos fatoriais é: n! = n * ( n − 1)! Uma função recursiva cria a cada chamada um novo conjunto de variáveis locais. A função é recursiva se um comando no corpo da função a chama. 1. 19. erro[num]). 24. 16. 37. } 21. "Segundo Erro tres\n". 30. 32. 11. 44. 8. p). 23. erro[num]). void mostra_erro1(int num) { char *erro[]= { "Primeiro Erro zero\n". Um exemplo não recursivo: int fact(int n) { int t. t<=n. printf("End. 9. } void mostra_erro2(int num) { char *erro[]= { "Segundo Erro zero\n". 17. 3.h> void mostra_erro1(int num). } 10. } /*Declaração das variáveis t e answer*/ /*retorna answer*/ Um exemplo recursivo: 49 . 15. 13. * 3 * 2 * 1 5! = 4 * 3 * 2 * 1 = 4 * 3! onde n é o número inteiro positivo. da funcao: %p\n". t++) answer=answer*(t). "Primeiro Erro dois\n".2 Recursividade Em C. 18. for(i=0. printf("%s". 27. p=mostra_erro2. void mostra_erro2(int num). "Segundo Erro um\n". 6. 4. uma função que chama a si mesma repetidamente um número finito de vezes. #include <stdlib. answer. }.h> #include <stdio. 28. 31. 34. }. i++) p(i). 38. 26.. Este recurso é muito útil em alguns tipos de algoritmos chamados de algoritmos recursivos. 20. p=mostra_erro1. 2. 10.

argc). 1. 4.4 Funções de String Função gets(): É utilizada para leitura de uma string através do dispositivo padrão. if (n==1) return(1). 9.h> int main(void) { char string[80]. printf("\nThe environment string(s) on this system are:\n\n"). 6. i < argc. i.h> #include <stdio. 7. char * argv[]) { int i. 10. 12. printf("Input a string:"). A função gets() não testa limites na matriz em que é chamada. 5. 2. #include <stdlib. 3. 5. #include <stdio. answer. answer=fact_r(n-1)*n. Há dois argumentos internos especiais: argc e argv.int fact_r(int n) { int t. argv[i]). 4. 2. return(answer).h> #include <stdlib. O parâmetro argv é um ponteiro para uma matriz de ponteiros para caractere.h> int main(int argc. 5. 8. 3. 4. return(0). int main(int argc. return(0).h> int main(int argc. 7. 8. printf("The value of argc is %d \n\n". até que o ENTER seja pressionado. 8. char * argv[]) { if (argc!=2) prinf(”Voce esqueceu de digitar seu nome\n”). } /*Declaração das variáveis t e answer*/ /*retorna answer*/ 10. else printf(”Ola %s!\n”. } 10. 50 . Ele é sempre pelo menos 1 porque o nome do programa é qualificado como primeiro argumento. } 1. printf("These are the %d command-line arguments passed to main:\n\n". for (i = 0.3 Função main A função main pode aceitar parâmetros via argumentos da linha de comando. 11. 9. gets(string). 10. argc). i++) printf(" argv[%d]: %s\n". argv[1]). 7. Cada elemento nessa matriz aponta para o argumento da linha de comando. #include <stdio. Sintaxe (conio. 2. Um argumento da linha de comando é a informação que segue o nome do programa na linha de comando do sistema operacional.h> #include <stdlib. char* argv[]) O parâmetro argc contém o número de argumentos da linha de comando. 11. 6. 1. 3.h): char *gets(char *str). 6. 13.

string). const char *str2).h> int main(void) { char string[10]. 8.h> #include <stdio. str1).h> int main(void) { char s1[80]. Não verifica tamanho. printf("%s\n".9.h): int puts(const char *str). 1. 11. gets(s1). strcpy(string. 6. 5. 2. Sintaxe (string. 5. return(0). 6. 6.h> int main(void) { char string[] = "This is an example output string\n".h> #include <stdio. strcat(s2. 13. gets(s2). s2). puts(string). 9. 5. string).h): char *strcat(char *str1. s1). #include <stdlib. 1. 7. s2[80]. 4. 7. Se str1 > str2. 4. 10. 9. printf("The string input was: %s\n". 10. char *str1 = "abcdefghi". return(0). *buf2 = "bbb". 1. printf("%s\n". 3. Sintaxe (string. #include <stdlib. Sintaxe (string. 9. #include <stdlib. coloca um '\n' no final. Reconhece os códigos de barra invertida. 51 . 1. *buf3 = "ccc". 12. 10. } Função puts(): Escreve o seu argumento no dispositivo padrão de saída (vídeo). 3. 6. Sintaxe (stdio. const char *origem). 3. 2. } Função strcmp(): Compara duas strings. 4.h): int strcmp(const char *str1.h> int main(void) { char *buf1 = "aaa". return(0). se forem iguais devolve 0. devolve < 0. } Função strcpy(): Copia o conteúdo de uma string. 3. 8. Do contrário se str1 < str2. 7. return(0). #include <stdlib. 2. const char *str2). 8. 5.h> #include <stdio. 11. 4. } Função strcat(): Concatena duas strings. 11. 2.h> #include <stdio.h): char *strcpy(char *destino. devolve > 0.

4. double x = 0. if (ptr > 0) printf("buffer 2 else printf("buffer 2 return(0). 14. return(0). result). Sintaxe (math. is less than buffer 3\n"). 2.5. 6. 9. } 52 .h): double atan(double arg). Sintaxe (math. 3.h> #include <math.h> int main(void) { double result. 3. 9. is less than buffer 1\n").h> #include <math. 17. 4. 1. ptr = strcmp(buf2. 12. 8. 5. Sintaxe (math. x. #include <stdlib. 11.h> #include <stdio. buf3).h> int main(void) { double result. } Função asin(): Devolve o arco seno do argumento.h> #include <stdio. buf1). 18. 8. result = asin(x). double x = 0. 3. 2. is greater than buffer 3\n").7. 15.5.h> #include <math. 12. } Função atan(): Devolve o arco tangente do argumento. result = acos(x). x. 10. #include <stdlib. } int ptr. return(0). is greater than buffer 1\n"). 8.h> #include <stdio.5 Funções Matemáticas Função acos(): Devolve o arco co-seno do argumento. 12. printf("The arc sin of %lf is %lf\n". 11. 11. 16. return(0). x. 8. 7. 20. 6. if (ptr > 0) printf("buffer 2 else printf("buffer 2 ptr = strcmp(buf2.h): double acos(double arg). 4. 12. result). double x = 0. 10. 10. printf("The arc cosine of %lf is %lf\n". 7. printf("The arc tangent of %lf is %lf\n". 19. 9. 7. result). 13. 2. 9. 11. 1. 5. 5. 6.5. 10. 1.h): double asin(double arg). 10. #include <stdlib. result = atan(x).h> int main(void) { double result.

2. printf("The sin of %lf is %lf\n". x = 0. Sintaxe (math.5. 8. result). result = cos(x). 4. 4. 7. printf("The tan of %lf is %lf\n". 4.h> int main(void) { double result. x.h> int main(void) { double result. } Função sin(): Devolve o seno do argumento. 10. } Função tan(): Devolve a tangente do argumento. 6. printf("The cosine of %lf is %lf\n". 6. printf("'e' raised to the power of %lf (e ^ %lf) = %lf\n". x.5. 12.h> #include <math. result). 10. 11. return(0). 11.h> #include <math. 1. 3. 5. 7. double x = 4. 5. Sintaxe (math.h> int main(void) { double result. 9.h> int main(void) { double result. 9.0. } 53 .h): double sin(double arg). result). Sintaxe (math. 10. result = exp(x). 4.Função cos(): Devolve o co-seno do argumento. 2. 8. Sintaxe (math. 11.h): double tan(double arg). 1. 1.h> #include <math. #include <stdlib. x. 2. 2. return(0). #include <stdlib. return(0). 9. 6. result).h> #include <stdio.h> #include <stdio.h): double cos(double arg). } Função exp(): Devolve o logaritmo natural e elevado à potência arg. 5. return(0). 11. 3.h> #include <stdio. #include <stdlib. x.h> #include <stdio. result = sin(x).h): double exp(double arg). 6. 3. 9. 7. #include <stdlib. x = 0. 8. 8. 3. 5. 1. double x = 0. result = tan(x). 12.h> #include <math.5. 7. 10. x.

3. x.h): double fabs(double arg). 11.0. Sintaxe (math. return(0).h> int main(void) { double x = 5. y.y). 2. return(0). 1.h> #include <math. 2. result = log(x). 3. y. double x = 8. 1. return(0).h> #include <math. 6. 5. x. 12. 8. 1. double result. 7. #include <stdlib. 4.0. 8. #include <stdlib.0. printf("The natural log of %lf is %lf\n". Sintaxe (math. 9.h> #include <math. 6. } #include <stdlib. printf("number: %f absolute value: %f\n". 4. 9. result). y)). 3.h> int main(void) { float number = -1234. 10. y = 3. 2. return(0). 3. } Função fmod(): Devolve o resto de x/y.h): double pow(double base. number.6872. 4.h> #include <math. 3. 6.h> int main(void) 54 .h): double log(double arg).h> #include <math. 10. double expoente).h> int main(void) { double x = 2. Sintaxe (math. 6. 10. double y). 1. y = 2. fabs(number)). 4. pow(x.h> #include <stdio. x. #include <stdlib.h> #include <stdio. result). #include <stdlib. 7. 8. 9. printf("%lf raised to %lf is %lf\n". 11. 8. result = fmod(x.h): double fmod(double x.0.Função fabs(): Devolve o valor absoluto do argumento.h> #include <stdio. 5. 7. 2. 9.0. } Função log(): Devolve o logaritmo natural do argumento. 5. } Função pow(): Devolve base elevada à potência. 1. 7. 5. 4.h> #include <stdio. 5.h> #include <stdio. 2.h> int main(void) { double result. 12. printf("The remainder of (%lf / %lf) is %lf\n". Sintaxe (math. 10.

4. printf("The square root of %lf is %lf\n". } Função ctime(): Devolve um ponteiro para o horário de calendário na forma: dia mês ano horas:minutos:segundos ano \n\0 Sintaxe (time. printf("Hoje é: %s\n". exp(y*log(x))). Sintaxe (time.h> #include <time.h): char *ctime(const time_t *time).h> int main(void) { double x = 4. result). 6. printf("%lf raised to %lf is %lf\n". return(0). 8.h): double sqrt(double arg).t). 5. 8. 1.0.0. 3. } 55 . time(&t). } 10.h): time_t time(time_t *time). double x = 2. x. 2.h> int main(void) { time_t t. 7. { 7.h> #include <time. 9.0. 4. return(0).h> int main(void) { time_t t. 8. x.h> #include <stdio. 1. 1970 is %ld". 5. 8. 11. return(0). 11. 2. return(0). 3.6 Funções de Hora e Data Função time(): Devolve o horário atual de calendário do sistema. 10. result = sqrt(x). 9. 9. #include <stdlib. y. 6. 9.h> #include <math. 10.6. } Função sqrt(): Devolve a raiz quadrada do argumento. 7. #include <stdlib. 7. #include <stdlib. t = time(NULL). y = 3. 5. 6. 3. 10. printf("The number of seconds since January 1. result. 2. Sintaxe (math. 4. 11.h> #include <stdio. 1. ctime(&t)).h> #include <stdio. 10.

Elabore uma função que aceita como parâmetro 5 números reais e retorna o maior número.h> int main(void) { int i.h e stdlib. 1. A função randomize() inicia a geração de números aleatórios. µ= ∑X i =1 n i n 8. i<10. printf("Dez números randômicos de 0 a 99\n\n"). 13. 12.h>. Elabore uma função que aceita como parâmetro dois catetos e retorna o valor da hipotenusa. for(i=0. 2. 4. 56 . 4. return(0). 3. randomize().h> #include <stdio. Elabore uma função que receba 10 números reais e a média. 7. 10. Elabore uma função que receba uma string e troque todos os caracteres ‘a’ por ‘@’. i++) printf("%d\n". Elabore uma função que aceita como parâmetro o número do CPF e retorna 1 para válido e 0 para inválido. 3. 6. Elabore uma função que receba 10 números reais e retorna a média aritmética. 9. 11. 6. 8. 5. retornando o valor do desvio padrão.DEF .8 Exercícios 1.h): void randomize(void). rand() % 100). ABC.GHI − JK S1 = A *10 + B * 9 + C * 8 + D * 7 + E * 6 + F * 5 + G * 4 + H * 3 + I * 2 d1 = 11 − ( S1 MOD 11) IF d1 >= 10 THEN Dígito _ 01 = 0 ELSE Dígito _ 01 = d1 S 2 = A *11 + B *10 + C * 9 + D * 8 + E * 7 + F * 6 + G * 5 + H * 4 + I * 3 + Dígito _ 01 * 2 d 2 = 11 − ( S 2 MOD 11) IF d 2 >= 10 THEN Dígito _ 02 = 0 ELSE Dígito _ 02 = d 2 IF J = Dígito _ 01 AND K = Dígito _ 02 THEN Válido ELSE Inválido 5.7 Outras Funções Função randomize() e rand(): A função rand() devolve um número aleatório entre 0 e RAND_MAX.10. 7. Sintaxe (time. 2.h> #include <time. Elabore uma função que receba uma palavra (string) e retorna a quantidade de caracteres. Elabore uma função que aceita como parâmetro dois números reais e retorna a média aritmética. #include <stdlib. int rand(void). A constante RAND_MAX é definida na biblioteca <stdlib. } 10.

Elabore uma função que receba como parâmetro um número real e retorne 10% do valor. 14. São apresentados as seguintes fórmulas da trigonometria. Elabore uma função que receba como parâmetro um raio de uma esfera e retorne o volume de acordo com a fórmula abaixo. Elabore uma função que receba como parâmetro um número real e retorne o número elevado a potência 5. Elabore um programa e implemente as funções para o cálculo da tangente. Elabore uma função que receba como parâmetro um número real e retorne o número elevado a potência 2. Elabore uma função que receba como parâmetro um número real e retorne a raiz quadrada. sen α cos α cos α cotgα = sen α tgα = sec α = 1 cos α 1 sen α cos sec α = 17.σ= ∑ (X i =1 n i − µ) 2 n 9. Elabore um programa e implemente as funções para o cálculo de: sen (a + b ) = sen (a )* cos(b ) + sen (a )* cos(b ) cos(a + b ) = cos(a )* cos(b ) − sen (a )* sen (b ) tg (a ) + tg (b ) tg (a + b ) = 1 − tg (a )* tg (b ) sen (2 * a ) = 2 * sen (a )* cos(a ) cos(2 * a ) = cos 2 (a ) − sen 2 (a ) sen (a − b ) = sen (a )* cos(b ) − sen (a )* cos(b ) cos(a − b ) = cos(a )* cos(b ) + sen (a )* sen (b ) tg (a ) − tg (b ) tg (a − b ) = 1 + tg (a )* tg (b ) cos(2 * a ) = 2 * cos 2 (a ) − 1 cos(2 * a ) = 1 − 2 * sen 2 (a ) 2 * tg (a ) tg (2 * a ) = 1 − tg 2 (a ) 57 . Elabore uma função que receba como parâmetro um número inteiro e imprima o valor em extenso na tela. V = 4 * π * R3 3 10. São apresentados as seguintes fórmulas da trigonometria. 16. 11. 13. cotangente. secante e cossecante de um ângulo α. Elabore uma função que receba como parâmetro um número real e retorne o número elevado a potência 3. 15. 12.

e verificar se a circunferência passa pela origem. apresentem a equação da circunferência. a relação entre x e y é dada pela equação abaixo (equação da circunferência). os pontos em que a circunferência corta o eixo Ox e Oy. dado o centro C e a distância r. Elabore funções que. o conjunto de pontos formado num plano cuja distância a C é igual a r é denominado circunferência de centro C. 58 .18. Se P(x. Dado um ponto C e uma distância r. y) é um ponto qualquer da circunferência.

isto é. para o armazenamento da informação.1 Utilização da memória de um programa. um programa em execução pode. solicitar a alocação do espaço e utilizar convenientemente os dados. ALOCAÇÃO DINÂMICA Um programa necessita de memória para armazenar informações. Existem duas maneiras fundamentais de um programa alocar memória do computador. void *calloc(size_t num. A primeira forma é através de variáveis locais e globais (alocação estática). As variáveis globais são alocadas em uma região pré-definida e as variáveis locais são alocadas em uma parte da memória definida como pilha. size_t size). A segunda forma é através da alocação dinâmica. Para este tipo de alocação necessita-se definir de antemão a quantidade de armazenamento necessária. Função calloc() :Aceita como parâmetro num números de elementos de size bytes de memória e retorna um ponteiro para o bloco alocado (num*size) ou nulo (NULL) se indisponível. Em C ANSI são definidos quatro funções: Função malloc() :Aceita como parâmetro size bytes de memória e retorna um ponteiro para o bloco alocado ou nulo (NULL) se indisponível.11. A figura 11. void *malloc(size_t size). ou seja. O armazenamento é realizado em uma região de memória livre. Pilha Heap Variáveis Globais Código do Programa Figura 11. que é fixo durante todo o tempo de execução do programa.1 mostra conceitualmente como um programa utiliza a memória (a posição e o tamanho variam de acordo com o tipo de processador). A alocação dinâmica é o processo de alocar espaço de memória do computador em tempo de execução. ou heap. sempre que necessário e houver a disponibilidade de espaço em memória. 59 . cada variável recebe um endereçamento de memória e o respectivo tamanho.

calcule a média aritmética dos elementos e mostre todos elementos maiores ou iguais à media e sua respectiva posição na vetor. printf(”O endereço do bloco alocado é %p\n”. Elabore um programa que aloque dinamicamente um vetor de n números reais. rg. excluir um cliente do cadastro. } *y=10. calcule e mostre o maior e o menor número. imprimir informações de um determinado cliente.&y). Este programa deve permitir a inserção de novos clientes. 7. complemento. return(0). 14. telefone. fax e celular. 9.y).h> #include <stdlib. 6. estado. 18. Se size é zero. 10. Se p é nulo. São necessários as seguintes informações do cliente: nome. bairro. 15. 19. 12. 16. carregue. editar dados de clientes cadastrados. 2. numero. 8. exit(0). free(y). #include <stdio. Por exemplo: void free(void *p). void *realloc(void *p. endereço. size_t size). cep. calcule e apresente a média aritmética e o desvio padrão.h> int main(void) { float *y. if (!y) { printf(”Memória indisponível!\n”).Função realloc() :Aceita como parâmetro o ponteiro do bloco de memória já alocada e um novo tamanho size bytes. 5. 11. Elabore um programa que aloque dinamicamente um vetor de 10 números reais. 17. 2. 4. leia. Função free() :Aceita como parâmetro o ponteiro do bloco de memória alocada e devolve ao heap. 1. 3. Um ponteiro para o bloco de memória é devolvido porque realloc() pode precisar mover o bloco para aumentar seu tamanho. 3. printf(”O conteúdo para que y aponta é %f\n”. y=(float*)malloc(sizeof(float)). pesquisar clientes e relatório. cidade. sexo. o conteúdo do bloco antigo é copiado para o novo bloco. Faça um programa de cadastro de clientes. realloc() aloca size bytes de memória e devolve um ponteiro para a memória alocada. estado civil. carregue. 5. Elabore um programa que aloque dinamicamente um vetor 10 de números reais. apresente o conteúdo e o endereço de cada posição do vetor. printf(”O endereço de y é %p\n”. 13. data de nascimento. 4. a memória apontada por p é liberada.1 Exercícios 1. Elabore um programa que aloque dinamicamente três números reais. } 11.*y). Se isso ocorrer. sobrenome. 60 .

o nome do cliente que realizou o serviço mais caro. 6. cliente). Cada novo cliente. quantos são do sexo masculino e feminino. a média dos valores. aloca-se dinamicamente um registro e atribui o endereço desse bloco a uma posição do vetor. data. quantos são solteiros(as).• relatório deve calcular a média de idade. quantos divorciados(as). 61 . serviço realizado. Leia as informações sobre várias ordens de serviço e determine. Faça um programa contendo os serviços que uma oficina mecânica pode realizar: • • Ordem de serviço (número da OS. listar as cidades e a respectiva quantidade de clientes por cidade. • • • Para armazenar as informações dos clientes. valor. quantos são casados(as) . juntamente com a descrição desse serviço e a data de sua realização. ao final. Criar também uma função para ordenar os clientes. utilize um vetor de ponteiros (deve-se iniciar todos ponteiros com nulo).

Nem todos os arquivos apresentam os mesmos recursos. o sistema de E/S do C fornece um nível de abstração entre o programador e o dispositivo utilizado. O arquivo STDIO. o sistema de arquivos com buffer transforma-os em um dispositivo lógico chamado stream. Essa abstração é chamada de stream e o dispositivo real é chamado de arquivo. 62 . FILE *arq. como o console. Uma vez aberto o arquivo. incluindo terminais.H é definida também a macro EOF (geralmente definida como –1). mas não todos os arquivos.H seja incluído nos programas que as utilizem. Isto é. O tipo size_t é essencialmente o mesmo que um unsigned. Isso revela um ponto importante sobre o sistema de E/S do C: todos os streams são iguais. informações podem ser trocadas entre ele e o programa. Essas funções exigem que o cabeçalho STDIO. um arquivo em disco pode suportar acesso aleatório enquanto um teclado não pode. Em C um arquivo pode ser qualquer coisa. Por exemplo. acionadores de discos e acionadores de fita. enquanto o tipo FILE será discutido na próxima seção.1 “Streams” e Arquivos O sistema de E/S do C fornece ao programador uma interface consistente. desde um arquivo em disco até um terminal ou uma impressora. geralmente no final do processamento.12. Um stream é associado com um arquivo específico através de uma operação de abertura. a mesma função pode escrever dados em um arquivo em disco ou em algum outro dispositivo. Quando não for mais necessário trocar informações com o arquivo. Todos os streams se comportam de maneira semelhante.H fornece protótipos para as funções de E/S e define também os tipos size_t e FILE. Em STDIO. devemos desassociar o stream do arquivo através de uma operação de fechamento. sendo tal valor devolvido quando uma função de entrada tenta ler além do final de um arquivo. O sistema de arquivos ANSI é composto de diversas funções para a manipulação de arquivos. Pelo fato dos streams serem independentes dos dispositivos reais. O sistema de arquivos do C ANSI foi projetado para trabalhar com uma grande variedade de dispositivos de E/S. MANIPULAÇÃO DE ARQUIVOS 12. independente do dispositivo real sendo acessado. Embora cada um dos dispositivos seja muito diferente. algumas das quais serão vistas no decorrer deste capítulo.

21. Enquanto que no acesso aleatório é feito em qualquer posição do arquivo sem que informações anteriores precisem ser acessadas. 9. 8. } if ((out = fopen("TESTFILE. 19. Tabela 12. que indica a localização de início de leitura ou gravação. 4. 13. "r"))== NULL) { printf("Cannot open input file. *out.\n").DAT".BAK".1. return 1. out). return(0). 17. 12.h> Abre Cria Abre Cria um um um um arquivo arquivo arquivo arquivo Significado texto para leitura texto para escrita binário para leitura binário para escrita int main(void) { FILE *in. 6. 22. 18.1 Os valores para o modo de abertura de arquivo. 11. int fclose(FILE *arq).\n"). Função fopen() : Abre um arquivo. } 63 . 5. No acesso seqüencial.12. const char* modo). 14. Isto pode ser feito através de funções que alteram indicador de posição corrente para determinada localização no arquivo. 2. 7. } while (!feof(in)) fputc(fgetc(in).2 Tipos de Acesso Os tipos de acesso aos arquivos podem ser seqüencial ou aleatório.3 Funções Manipulação de Arquivos Função fclose() : Fecha um arquivo. FILE *fopen(const char nome_arquivo. #include <stdio. Este posicionamento aleatório é feito em relação a três possíveis origens que são passados como argumento de funções: Início. "w"))== NULL) { printf("Cannot open output file. 12.h> #include <stdlib. 16. 3. posição corrente ou fim. fclose(in). 15. a leitura e a transferência de dados devem ser feitas percorrendo seqüencialmente os bytes no arquivo. O modo de abertura de arquivo pode ser conforme apresentada na tabela 12. fclose(out). if ((in = fopen("TESTFILE. return 1. 23. 20. 10. O acesso aos dados é feito através de um ponteiro indicador da posição corrente no arquivo. Modo r w rb wb 1.

} long filesize(FILE *stream) { long curpos. Função remove() : Apaga um arquivo. char c = 'C'. 1. "%d %c %f". void rewind(FILE *arq). . int fseek(FILE *arq. 2. Macro SEEK_SET SEEK_CUR SEEK_END 1. 4. 4. 8. 9.. int fprintf(FILE *arq. "w+"). 7. 14. int remove(const char *nome_arquivo). 3. c. 3.h> int main(void) { FILE *stream. curpos. 17. 19. 5. curpos = ftell(stream). if (!stream) exit(1). 6. "This is a test"). 16. i. fprintf(stream.FIL". 15. return 0. 22. 7. fclose(stream). float f = 1. 11. return length.234. 14. 9. SEEK_SET). 15. 24.h: Tabela 12. 23. fclose(stream). stream = fopen("MYFILE. printf("Tamanho de MYFILE. int origin). fprintf(stream. O parâmetro origin é uma das seguintes macros definidas em stdio.h> #include <stdlib.Função fprintf() : Escreve argumento em um arquivo. 11. 13. const char *control_string. fseek(stream. } Função fseek() : Posiciona o arquivo em um byte específico. Origin Início do arquivo Posição atual Final de arquivo int main(void) { FILE *stream. 21. } Função ferror() : Devolve verdadeiro se ocorreu um erro durante a última operação no arquivo. SEEK_END).. 8. #include <stdio. filesize(stream)). 10. int ferror(FILE *arq). return 0. #include <stdio. 6. 10. 64 .2 Os valores para o modo de abertura de arquivo. length.).h> long filesize(FILE *stream). 12. length = ftell(stream). "w"). stream = fopen("DUMMY. long numbytes. 13.h> #include <stdlib. 16.TXT". f).TXT is %ld bytes\n". fseek(stream. 20. 5. 0L. 12. int i = 100. 2. Função rewind() : Recoloca o indicador de posição de arquivo no início do arquivo. 18.

size_t num_bytes.\n").h> int main(void) { FILE *stream. &f). 19. int s[10]. i<10. 15.$$$". 10. 5. c. 3. 4. 7. printf("x[%d]=%d\n". fclose(stream). 9. if ((stream = fopen("TEST. } for (i=0. 20.h> #include <stdlib. Função fscanf() : Lê argumento de um arquivo. stream = fopen("DUMMY.i. 17. int i. 10. "r"). 13. 1. stream). int feof(FILE *arq). 13. 14.Função fflush() : Esvazia um stream. 6. 12. 11. "Cannot open output file. } 65 . 8.h> #include <stdlib. 12. char c. . 13. "rb")) == NULL) { fprintf(stderr. printf("%d %c %f". 1. #include <stdio. return 0. size_t count. 18. f). &i.. return 0. int fscanf(FILE *arq. 4. fclose(stream). 8.FIL". size_t fread(void *buffer. 15. if (!stream) exit(1). FILE *arq). return 0. } Função feof() : Devolve verdadeiro se fim de arquivo for atingido.). 7. 7. int fflush(FILE *arq). 3. 1. 2. 17. 2. if (feof(stream)) printf("We have reached end-of-file\n"). s[i]). 16. #include <stdio.. "%d %c %f". float f. 11. i. 11. 14. 6. "r")==NULL) exit(1). 14. 12. #include <stdio. 4.FIL". 16. 3. return 1. fscanf(stream. const char *control_string.h> #include <stdlib. i++) { fread (&s[i]. 1. 6. Se não ocorrer erro retorna count. } fclose(stream). fgetc(stream). &c. sizeof(int). 2. 9. } Função fread() : Lê count blocos de num_bytes de arq para buffer. 5. i. 8. 10. 5.h> int main(void) { FILE *stream. if ((stream = fopen("DUMMY.h> int main(void) { FILE *stream. 9.

"Cannot open output file. 9. if ((stream = fopen("TEST. do { /* read a char from the file */ ch = fgetc(stream). 12. /* seek to the beginning of the file */ fseek(stream. 29. 8. strlen(string). /* write a string into the file */ fwrite(string. Faça um programa de cadastro de clientes. 12. 23. size_t num_bytes. fclose(stream). 15.h> #include <stdio. i. 16. FILE *arq). 3.FIL". scanf("%d". fwrite(&s[i]. 5. } Função fgetc() : Devolve o próximo caractere da stream de entrada na posição atual e incrementa o indicador de posição do arquivo. size_t count. int s[10]. 1. #include <string. 14. int fgetc(FILE *arq). return 1. 21. 19. "w+").i). 1. SEEK_SET). } fclose(stream). 0. 2. i++) { printf("x[%d]=". 19. 3. 7. return 0. 6. 18. Este programa deve permitir a inserção de novos clientes. 30. 16. char string[] = "This is a test". } while (ch != EOF). 17.h> #include <stdlib. size_t fwrite(void *buffer. 17.h> int main(void) { FILE *stream. char ch. 4. /* display the character */ putchar(ch). 8. 31. 20. 6. imprimir informações de um determinado cliente. 10. 18. 1. 10. /* open a file for update */ stream = fopen("DUMMY. #include <stdio. 5. 28. 2.4 Exercícios 1. pesquisar clientes e relatório. São necessários as seguintes 66 .Função fwrite() : Escreve count blocos de num_bytes de buffer para arq.&s[i]).\n").h> int main(void) { FILE *stream. 27. 21. } 12. 15. } for (i=0. 22. 20. stream). return 0. excluir um cliente do cadastro. stream). 4. 14. 26. 7.$$$". 1. 13. "wb")) == NULL) { fprintf(stderr. 11. editar dados de clientes cadastrados. 9. Se não ocorrer erro retorna count. 24. i<10. 13. 25. sizeof(int). 11.

cidade. Implementar operações para manipular arquivos. aloca-se dinamicamente um registro e atribui o endereço desse bloco a uma posição do vetor. data. data de nascimento. quantos divorciados(as). O programa consulta um arquivo (exercício 3) que contém a disponibilidade dos produtos. utilize um vetor de ponteiros (deve-se iniciar todos ponteiros com nulo). telefone. bairro. 4. 2. quantos são casados(as) . juntamente com a descrição desse serviço e a data de sua realização. sexo. 3. endereço. estado civil. numero. cep. Faça um programa contendo os serviços que uma oficina mecânica pode realizar: • • Ordem de serviço (número da OS. Criar também uma função para ordenar os clientes. cliente .ler informações de um arquivo). sobrenome. Faça um programa que gerencia os produtos armazenados em uma farmácia. estado. fax e celular. • relatório deve calcular a média de idade. valor. Leia as informações sobre várias ordens de serviço e determine. ao final. Deve-se criar um arquivo que armazene as informações dos produtos e a quantidade disponível. • • • • Para armazenar as informações dos clientes. Cada novo cliente. listar as cidades e a respectiva quantidade de clientes por cidade. Faça um programa que gerencie a venda de produtos de uma farmácia. o nome do cliente que realizou o serviço mais caro. 67 . serviço realizado. a média dos valores. quantos são do sexo masculino e feminino. rg. quantos são solteiros(as). A cada venda deve-se atualizar a quantidade no arquivo.informações do cliente: nome. complemento.

int count) { int a. for (i=0. n.n). if (!q) exit(1). Considerando-se o seguinte exemplo são apresentados os algoritmos de ordenação a int main(void) { int *q.h> void void void void void void void void selecao(int *p. troca(int *p. 25. 29. 28. return 0. void shakesort(int *p. 15. 34. scanf("%d".. 31. 10. i.\n"). a>0. qs(int *p. printf("Quantos números deseja:"). &n). 38. 16. int count) { int i. 19. i++) printf("%d ". 5. Existem três método básicos para ordenar matrizes: • • • seguir: 1. a<count. Troca. int left. i<count. 24. int count). a--) { if (p[a-1]>p[a]) { 68 . Consiste em dois loops.h> #include <stdlib. toda a estrutura de dados é transferida. b. temp. a++) for (b=count-1. free(q). 21. 3. print(q. a troca de dois elementos adjacentes. i<n. for (a=1. shell(int *p. shakesort(int *p. 35. ORDENAÇÃO Ordenação é o processo de arranjar um conjunto de informações semelhantes numa ordem crescente ou decrescente. int count). print(p. int count). int count). O loop j é o loop interno. estes dois são trocados. int count) { int a. quicksort((int *p. 22. 7. q=(int*)malloc(n*sizeof(int)).n). 9. b--) { if (p[b-1]>p[b]) { temp=p[b-1]. Seleção.. Geralmente. Essa operação é repetida tantas vezes quantas sejam o número de registros da tabela. 23. 14. 27. b>=a. 4. 26. exchange. for (a=count-1. printf("\n"). e ele passa por cada item da tabela (do fim para o início). 32. e compara a si próprio (j) com o anterior (j+1). 12. temp. } . 6.13. apenas uma porção dessa informação é usada como chave da ordenação. } print(q.. 30. quando uma troca se torna necessária. 18. 13. } void print(int *p. scanf("%d". Caso seja maior que o próximo. 20. int count). do { exchange=0. 11. insercao((int *p. Inserção. 33. 2.n). 8. #include <stdio. printf("\nOrdenando. shakesort(q. 13.. Após j ter passado por toda a tabela.1 Ordenação por Troca A ordenação por troca envolve repetidas comparações e. 17. for (i=0. 41. um dentro do outro (i e j). int count). p[i]). 39. int count). Essa chave é utilizada nas comparações. 40. quando a informação é ordenada. print(int *p. 37. se necessário. mas. int right). &q[i]). 36. 42. printf("\n").i). void troca(int *p. ele volta ao final e i é incrementado. i++) { printf("x[%d]=". count).

em cada etapa. exchange=1. Durante a aplicação do método de seleção a lista com n registros fica decomposta em duas sub listas. elas já 69 . A idéia de funcionamento é semelhante ao ordenamento de cartas de baralho na mão de um jogador. quando todas as "cartas" foram inseridas. void selecao(int *p. temp. A mão esquerda começa "vazia" e a mão direita insere uma "carta" de cada vez na posição correta. No início a sub lista ordenada é vazia e a outra contém todos os demais. p[a]=temp. } } if (exchange) { p[c]=p[a]. a<count-1. p[a]=temp. em selecionar o maior (ou o menor)elemento e alocá-lo em sua posição correta dentro da futura lista ordenada. b<count. p[a]=temp. a++) { exchange=0. } } } 13. int count) { int a. exchange=1. exchange. uma contendo os itens já ordenados e a outra com os restantes ainda não ordenados. p[a-1]=p[a]. As etapas(ou varreduras) como já descrito acima consiste em buscar o maior elemento da lista não ordenada e colocá-lo na lista ordenada. } } } temp=p[a-1].2 Ordenação por Seleção A ordenação por seleção consiste. Ao final. } } for (a=1. for(b=(a+1).No final do processo a sub lista ordenada apresentará (n-1) itens e a outra apenas 1. a<count. } } } while (exchange). b. temp=p[b]. c=a. p[a-1]=p[a]. } 13. c. b++) { if (p[b]<temp) { c=b. a++) { if (p[a-1]>p[a]) { temp=p[a-1]. p[b]=temp.3 Ordenação por Inserção O algoritmo de ordenação por inserção é bastante simples e eficiente para uma quantidade pequena de números. for (a=0.p[b-1]=p[b]. exchange=1. temp=p[a].

o i-ésimo elemento é inserido em seu lugar apropriado entre os(i-1) elementos já ordenados. x. p[j+gap] = x. count). O algoritmo foi criado por Donald L. No início. gap. uma com os elementos já ordenados e a outra com elementos ainda por ordenar. j. até encontrarmos.estão ordenadas. Nos métodos de ordenação por inserção. o gap inicial é igual a 7. void shell(int *p.4 “Shell Sort” O algoritmo de ordenação shell é um algoritmo de ordenação por inserção. O gap. void insercao(int *p. int count) { int a. temp. for (b=(a-1). e 8o. int count) { int i. Shell em 1959. print(p. São então comparados os elementos 1o. b--) p[b+1] = p[b]. Neste algoritmo. k++) { gap = a[k]. e assim por diante. no início. b. é igual à parte inteira da divisão do número de elementos da lista por 2. A partir da posição 0.. a<count. O mesmo processo ocorre a partir da posição n-1. a++) { temp=p[a]. e 9o. ao invés dos dados serem comparados com os seus vizinhos. k. 70 . for (k=0. i<count. A maior parte dos elementos já vão para suas posições aproximadas. 2o. se a nossa lista tem 15 elementos. for (j=i-gap. a cada etapa i.3.2. a sub lista ordenada é formada trivialmente apenas pelo primeiro elemento da lista. procurando um elemento menor do que x.5. j=j-gap) p[j+gap] = p[j]. for (a=1. começamos a procurar um elemento maior do que x. i++) { x=p[i]. k<5. a[5]={9.. for (i=gap.1}.5 “Quicksort” O algoritmo de ordenação quicksort é um algoritmo de ordenação por troca. } } } 13. Baseia-se na escolha de um elemento central. Por exemplo. Durante o processo de ordenação por inserção a lista fica dividida em duas sub listas. p[b+1]=temp. } } 13. b>=0 && temp<p[b]. Isso é repetido até que o gap seja igual a 0. é criado um gap. x<p[j] && j>=0. o gap é diminuído em 1 e é feita uma nova passagem. Ao terminar de passar por todos os elementos da lista.

} 71 . if (left<j) qs(p. x=p[(left+right)/2]. j=right. i++. x. } }while (i<=j). p[i]=p[j]. j. j--. int count) { qs(p. count-1). if (i<=j) { y=p[i]. right). j). while ((x<p[j]) && (j>left)) j--. int left.Quando o índice da esquerda (i) for menor do que o índice da direita (j). O processo se repete de forma recursiva para cada subconjunto (esquerda e direita do elemento x). y. int right) { int i. trocamos estes valores. if (i<right) qs(p. } void qs(int *p. i. i=left. do { while ((p[i]<x) && (i<right)) i++. até termos um subconjunto com um único elemento. left. void quicksort(int *p. até que i>=j. p[j]=y. 0.

o último item colocado na pilha será o primeiro a ser removido. Filas. respectivamente. quando necessário. Listas. First-out). 14. A P G U W W U G P A A P A G P A U G P A Figura 14. 72 . W U G P A U G P A G P A P A A Figura 14. existem basicamente quatro tipos de estruturas: • • • • Pilha.14.2 Ilustração exemplo da função pop. As duas operações básicas (armazenar e recuperar) são tradicionalmente chamadas de push e pop. ESTRUTURAS DE DADOS Um programa consiste de duas coisas: algoritmos e estruturas de dados. A estrutura de dados é importante para armazenar os dados e recuperá-los. isto é. De acordo com a forma de acesso (armazenamento e recuperação) aos dados.1 Ilustração exemplo da função push.1 Pilhas Pilhas são estruturas de armazenagem e recuperação de dador em ordem LIFO (Last-in. Árvores Binárias. de forma automática em uma ordem predeterminada.

A fila opera utilizando duas funções: entra e sai. o primeiro item colocado na fila será o primeiro a ser removido.1 Filas Circulares Quando uma Fila atinge o limite do vetor de armazenamento.14. As filas podem ser utilizadas em simulações. X X Y Z X Y Y Z X X Y Z Z Y X Y Z Z Figura 14.2. Desta forma. 14. isto é. First Out).2 Filas Filas são estruturas de armazenagem e recuperação de dados em ordem FIFO (First In. 73 . Um melhoramento das Filas simples seria a Fila Circular.3 Ilustração função entra e função sai de uma fila. não é mais possível colocar nenhum item na fila. entre outros. distribuição de eventos.

3 Listas Ligadas São estruturas de armazenagem e recuperação de dados de forma randômica.4 Ilustração de uma fila circular. A B Figura 14. isto é. 14.3.1 Listas Singularmente Ligadas Uma lista singularmente encadeada requer que cada item de informação contenha um elo com o próximo item da lista. uma lista encadeada. o elo proximo se torna um ponteiro para o primeiro nó da lista. 14. ou seja. Cada item de informação consiste em uma estrutura que inclui campos de informação e ponteiro de enlace. c) Devido ao nó ser incluído no início da lista. A adição de um nó no início de uma lista ligada é realizada em quatro etapas: a) Um nó vazio é criado. Cada porção de informação é armazenada em um item de informação e que carrega consigo um elo ao próximo item de informação. desde que itens também estejam sendo retirados (Fig. b) O campo info do nó é inicializado com um valor em particular. A adição de um nó pode ser realizada no início ou ao longo de uma lista ligada.qualquer número de itens poderia ser colocado na fila. Ele está vazio no sentido de que o programa que realiza a inserção não atribui quaisquer valores aos campos de dados do nó. 14. 74 . As listas encadeadas podem ser singularmente (simples) ou duplamente encadeadas. o valor corrente de topo.4).

c) Percorre a lista comparando o campo info do novo nó com cada nó da lista. Ele está vazio no sentido de que o programa que realiza a inserção não atribui quaisquer valores aos campos de dados do nó. d) A remoção de um nó no meio de uma lista deve ser realizada somente após efetuar as ligações necessárias afim de manter a consistência da lista. c) A remoção do primeiro nó da lista com pelo menos dois nós exige a atualização do ponteiro Primeiro. Deve-se observar que: a) Não se pode remover um nó de uma lista vazia. mas esse fato tem que ser refletido no valor do Primeiro.d) O novo nó precede todos os nós da lista. Consequentemente. d) Ao determinar a posição de inserção. O processo de adicionar um novo nó ao longo da lista de forma ordenada é realizada em quatro etapas: a) Um nó vazio é criado. o ponteiro Primeiro é atualizado para se tornar o ponteiro para o novo nó. b) O campo info do nó é inicializado com um valor em particular. 1 2 5 8 4 Primeiro Figura 14. o elo proximo do novo nó aponta para o elo proximo do nó corrente. o elo proximo do anterior do nó corrente aponta para o novo nó e. o ponteiro Primeiro deve ser atualizado. A A A Primeiro (1) Tmp Primeiro (2) Tmp Primeiro (3) 75 . A operação de remoção consiste em remover um nó do início ou ao longo da lista e retornar o valor armazenado nela. b) A remoção de um único nó de uma lista ligada de apenas um nó.5 Ilustração de uma lista singularmente ligada.

7 Ilustração de inserção em uma lista singularmente ligada. C S R A A Primeiro (1) Tmp C S R A A Primeiro (2) Tmp C S R A A Primeiro (3) 76 . C A C A C A Tmp (1) Primeiro Tmp (2) Primeiro Primeiro (3) Figura 14.Figura 14.6 Ilustração de inserção em uma lista singularmente ligada.

8 Ilustração de uma lista linear duplamente ligada.Figura 14. A inserção de um nó de forma ordenada em uma lista duplamente ligada pode ser realizada basicamente de três formas: • • • no início da lista. d) ponteiro Ultimo recebe novo nó. Se um dos elos tornar-se inválido. 1 9 3 5 Primeiro Último Figura 14.3. 14. b) O elo proximo do novo nó recebe Primeiro. O processo para a inserção no fim da lista é realizado em quatro etapas: a) Um novo nó é criado inicializando-se os dados (inclusive os ponteiro como nulo).8 Ilustração de inserção em uma lista singularmente ligada. O processo para a inserção no início da lista é realizado em quatro etapas: a) Um novo nó é criado inicializando-se os dados (inclusive os ponteiro como nulo). c) O elo proximo apontado por Ultimo recebe novo nó. c) O elo anterior apontado por Primeiro recebe novo nó. no fim da lista. 77 . no meio da lista. b) O elo anterior do novo nó recebe Ultimo. a lista pode ser reconstruída utilizando-se o outro elo. d) O ponteiro Primeiro recebe novo nó. A vantagem de possuir dois elos são: • • A lista pode ser lida em ambas as direções. O processo de adicionar um novo nó ao longo da lista duplamente ligada de forma ordenada é realizada em quatro etapas: a) Um novo nó é criado inicializando-se os dados (inclusive os ponteiro como nulo).2 Listas Duplamente Ligadas Uma lista duplamente ligada (ou lista linear duplamente ligada) consiste em dados e elos para o próximo item e para o item precedente.

b) O campo info do nó é inicializado com um valor em particular. 78 . Deve-se observar que: a) Não se pode remover um nó de uma lista vazia. O elo proximo do novo nó aponta para o nó corrente e. O elo anterior do novo nó aponta para o anterior do nó corrente. d) Ao determinar a posição de inserção. S S Primeiro (1) Ultimo Primeiro (2) Ultimo E S tmp Primeiro (3) Ultimo S S S S tmp Primeiro (4) Ultimo Primeiro (5) Ultimo Figura 14. o elo proximo do anterior do nó corrente aponta para o novo nó. do fim ou ao longo da lista e retornar o valor armazenado nela. o elo anterior do nó corrente aponta para o novo nó.9 Ilustração de inserção em uma lista duplamente ligada. c) Percorre a lista comparando o campo info do novo nó com cada nó da lista. A operação de remoção consiste em remover um nó do início.

subárvore esquerda e subárvore direita. Em cada nó contém um registro. Cada elemento de uma árvore binária é chamado nó da árvore.b) A remoção de um único nó de uma lista ligada de apenas um nó. a seguinte propriedade é verdadeira: • • • • • • Todos os registros com chaves menores estão na subárvore esquerda e todos os registros com chaves maiores estão na subárvore direita. 79 . d) A remoção do ultimo nó da lista com pelo menos dois nós exige a atualização do ponteiro Ultimo.9 Ilustração de uma lista circular duplamente ligada com cabeçalho. o ponteiro Primeiro e Ultimo deve ser atualizado. e. Uma outra construção possível é a lista circular ligada que pode conter ou não a indicação para o início da lista 1 9 3 5 Início Figura 14. Se um nó está no nível i então a raiz de suas subárvores estão no nível i+1. para cada nó. Os outros nós são chamados de nó interno. Árvore binária são árvores de grau 2. e) A remoção de um nó no meio de uma lista deve ser realizada somente após efetuar as ligações necessárias afim de manter a consistência da lista. Grau de uma árvore é o mais alto dentre os graus de seus nós. c) A remoção do primeiro nó da lista com pelo menos dois nós exige a atualização do ponteiro Primeiro. O número de subárvores de um nó é chamado grau daquele nó.4 Árvores Binárias Árvore binária é um conjunto finito de elementos que está vazio ou é particionado basicamente em três subconjuntos disjuntos: raiz. 14. O nível do nó raiz é 0. Um nó de grau zero é chamado de nó externo ou folha.

a subárvore da direita. Com a pós-ordenada. Um nó no nível n possui a profundidade n. em seguida.11. Na maneira pré-ordenada. a raiz. Isto é. Considerando-se o exemplo da figura 14. As subárvores (sucessores diretos) da raiz possuem profundidade 1. a ordem de acesso à árvore usando cada método é: d Ordenada a b c d e f g Pré-ordenada d b a c f e g Pós-ordenada a c b e g f d a b f c e g 80 . permitem o uso de listas ligadas e a divisão de um conjunto de dados em subconjuntos. cada nó é visitado da raiz. 18 e 23 Nível 4: 6 Nível 5: 7 Altura da árvore: 7 Figura 14.• • • A altura de um nó é o comprimento do caminho mais longo deste nó até um nó folha. A profundidade é o número de arestas da raiz até um determinado nó. O procedimento de acesso a cada nó na árvore é chamado de transversalização da árvore. a raiz e. a subárvore da esquerda e. Usando a forma ordenada. 12 e 20 Nível 3: 10. podem representar processos decisórios. A raiz possui profundidade 0. Embora árvores sejam fáceis de visualizar. em seguida. A maioria das funções que usam árvore é recursiva porque a própria árvore é uma estrutura de dados recursiva. administrando-as de forma hierárquica. depois. cada nó é visitado da subárvore da esquerda. cada subárvore é ela própria uma árvore. 13. A altura de uma árvore é a altura do nó raiz. pré-ordenada e pósordenada. Raiz: 15 Grau da árvore: 2 Nível 0: 15 Nível 1: 5 e 16 Nível 2: 2.10 Ilustração de uma árvore binária. As árvores podem ser utilizadas para administrar grandes quantidades de dados em uma ordem qualquer. Além disso. elas apresentam alguns problemas difíceis de programação. cada nó é visitado da subárvore da esquerda. a subárvore da direita e. a subárvore da direita. Existem três maneiras de percorrer uma árvore: de forma ordenada.

81 .11 Exemplo de árvore binária. 3.5 EXERCÍCIOS 1. Elaborar um programa que simule uma fila de atendimento. Elaborar as funções pop() e push() de uma pilha. 14. Elaborar um programa que simule o armazenamento e recuperação de uma pilha. Uma árvore binária ordenada é aquela em que a subárvore da esquerda contém nós que são menores ou iguais à raiz e os da direita são maiores que a raiz. 4.Figura 14. Elaborar as funções para armazenar e recuperar dados em uma fila. 2.

Lourenço. K. S.M. C. Rivest. “Projeto de Algoritmos com Implementações em Pascal e C” 4ªEdição. V.. “C Completo e Total” 3ªEdição Makron Books Ltda. Ascencio. J. “Circuitos Digitais” 3ªEdição. 1994. “Algoritmos .. B.C. 82 . São Paulo.G.R. N. A. Salles..S.S. 1995. Loudon.M. 2000. Angerami.. Rio de Janeiro/RJ. Tenenbaum.15..L. H. Editora Atual.Teoria e Prática”. Cormen. Pascal e C/C++”. Berkshire/UK. Rio de Janeiro/RJ.. Editora Prentice Hall.. S. P. Editora Pioneira Informática. Ziviani. Rio de Janeiro/RJ. Editora Pioneira Thomson. 2000. Schildt..V.. MacGraw-Hill International. São Paulo/SP. Aoki. “Treinamento em Linguagem C++ . BIBLIOGRAFIA Arakaki. Neto. Editora Campus. 1984. Stroustrup. 1997. 1992. Mizrahi. Pressman. Campos. Augenstein. O.V.Algoritmos.. 2002. 3ª.. D.Edição..F. “Fundamentos da Programação de Computadores . Editora Érica. 2002. 2002. Editora Makron Books.Edição Americana. Ince. 1999. Porto Alegre/RS. Alves Cruz. 1996. São Paulo/SP. 2000. São Paulo/SP. Stein.H. Drozdek.L. C. R. São Paulo/SP. “Estruturas de Dados Usando C” Makron Books Ltda. Editora Bookman. “Software Engineering: A Practitioner’s Approach (European Adaptation)” 5thEdition. São Paulo/SP. E. “A Linguagem de Programação C++”.. A. Langsam.J.C. “Estrutura de Dados e Algoritmos em C++”. “Fundamentos de Programação C: Técnicas e Aplicações” 2ªEdição. Y. A. São Paulo/SP. “Matemática Básica”. M.. D. Arakaki. R. A. A. Ferreira.. R.Módulo 2”. Leiserson. Choueri Júnior. Livros Técnicos e Científicos Editora. Tradução da 2ª. T. “Dominando Algoritmos com C” Editora Ciência Moderna.E. E.A.

16. APÊNDICE 16.1 Tabela ASCII 83 .

n = quantidade de algarismos –1. É um sistema muito utilizado em circuitos lógicos e aritméticos. Em um determinado momento ao longo desse processo. o tempo é medido utilizando um sistema de 24 unidades para as horas. surgiu a necessidade de medir grandezas. Utiliza 10 símbolos (algarismos) para representar qualquer quantidade: 0 1 2 3 4 5 6 7 8 9. É um sistema muito utilizado na área de microprocessadores. por 3 milhares. 84 . ou de acordo com a lei de formação: 3452 = 3 * 10 3 + 4 * 10 2 + 5 * 101 + 2 * 10 0 Sistema Binário (base 2): O sistema binário ou base 2 utiliza apenas dois símbolos para representar qualquer quantidade: 0 1. b = base do número. Cada algarismo ou dígito de um número binário é chamado de bit (binary digit). Por exemplo. um sistema de 12 unidades para os meses e um sistema de 10 unidades para os anos. Por exemplo. Sistema Hexadecimal (base 16): O sistema hexadecimal ou base 16 possui 16 símbolos para representar qualquer quantidade: 0 1 2 3 4 5 6 7 8 9 A B C D E F. o número 3452 é composto 4 algarismos. isto é. Os números de todos os sistemas numéricos podem ser decompostos de acordo com a lei de formação: Número = an * bn + an −1 * b n −1 + an − 2 * bn − 2 + K + a0 * b0 onde: an = algarismo. Para a representação de quantidades maiores que a base adota-se pesos para cada posição do algarismo. Para a compreensão de um circuito digital até um computador são importantes três sistemas numéricos: Sistema Decimal (base 10): O sistema decimal ou base 10 é o sistema mais utilizado no diaa-dia. 4 centenas. um sistema de 60 unidades para minutos e segundos.2 Sistema Numérico O homem é resultado contínuo da sua própria evolução. 5 dezenas e 2 unidades. Para medir essas grandezas o homem criou os sistemas numéricos.16.

correspondem ao número na base b.. para obter o equivalente em uma base b qualquer. 16.. (58)10 = (?) 2 58 / 2 = 29 resto = 0 29 / 2 = 14 resto = 1 14 / 2 = 7 resto = 0 7 / 2 = 3 resto = 1 3 / 2 = 1 resto = 1 (58)10 = (111010) 2 (58)10 = (?)16 58 / 16 = 3 resto = 10 (58)10 = (3A)16 85 . Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 ... basta aplicar a lei de formação: (1001) 2 = 1 * 2 3 + 0 * 2 2 + 0 * 21 + 1 * 2 0 = (9)10 (3A )16 = 3 * 161 + A * 160 = 3 * 16 + 10 * 1 = (58)10 Dado um número inteiro na base 10. O último quociente da divisão e os restos das divisões sucessivas. divide-se o número por b sucessivamente até que o quociente da divisão seja menor que b.A equivalência entre os números dos três sistemas numéricos é apresentado na seguinte tabela: Tabela 16.3 Conversão entre Bases Para converter um número de um sistema numérico qualquer para a base decimal. tomados na ordem inversa. Hexadecimal 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 .1 .. Binário 0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000 10001 .Equivalência entre os sistemas numéricos..

375 * 2 = 0. m = quantidade de algarismos da parte fracionária. b = base do número. A lei de Formação para números fracionários é: Número = an * b n + an −1 * b n −1 + an−2 * b n−2 + K + a0 * b0 + a−1 * b −1 + a−2 * b −2 + K + a−m * b − m onde: an = algarismo. Para a conversão de base 10 para base 2 ou base 16.000 → Fim (37. n = quantidade de algarismos da parte inteira –1.Existem uma relação estreita entre o sistema binário e o hexadecimal. a parte inteira é convertida separadamente pelo processo das divisões sucessivas. (3A )16 = (?) 2 3 → 0011 A → 1010 (3A )16 = (00111010) 2 (111010) 2 = (?)16 0011 → 3 1010 → A (111010) 2 = (3A )16 A conversão de números fracionários é realizada por partes: a parte inteira e a parte fracionária.0625)10 = (?)16 (37)10 = ( 25)16 0.000 →0 →1 →1 (37.0625)10 = (25.750 * 2 = 1.500 0.0625 *16 = 1 → 1 0.000 → Fim (8.375)10 = (1000.500 * 2 = 1. (8.375)10 = (?) 2 (8)10 = (1000) 2 0.750 0. A parte inteira resultante dos produtos formará os dígitos da parte fracionária do número convertido.011) 2 86 . A parte fracionária é utilizado o processo das multiplicações sucessivas pela base desejada. Esta relação vem do fato que o número 16 pode ser escrito como 24.1)16 0.

Sign up to vote on this title
UsefulNot useful