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

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

Neste texto.br Atualizado em: 01/02/2007 6 .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. Prof. Francisco Yastami Nakamoto emaito: yastami@unifieo. críticas e sugestões serão bem vindas. Quaisquer dúvidas. estruturas de dados e técnicas de programação baseado no livro texto e nas referências bibliográficas complementares. de forma resumida. os conceitos básicos da linguagem de programação C. encontra-se. Me.

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

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

o casal está preparando café para servir aos convidados. Seguindo os passos apresentados.uma série de passos organizados que descrevem um processo que se deseja seguir para dar solução a um problema específico.. então o objetivo principal é fazer o café.4 Representação da Lógica O algoritmo é a representação da resolução lógica de um problema de processamento de dados. 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. 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. ou seja. que atinge um objetivo pré-estabelecido. 9 . Se a água ferver. ” considerando-se que: “ . Entretanto. um algoritmo é um conjunto finito instruções seqüenciais. Adoçar o café.. um encontro de amigos na residência do casal Leila e Francisco... 1. Colocar a chaleira para ferver.. Colocar café em pó no filtro. Colocar a chaleira para ferver. acrescentar aos poucos a água no filtro. Considerando-se as definições apresentadas anteriormente.“ . Aguardar o processo de coar. 2. mas para isso é preciso do café.. certamente o objetivo será alcançado. executados num determinado período de tempo. é possível prever passos essenciais que podem comprometer a resolução do problema. Sendo anfitrião do evento. Por exemplo: 1. Então. 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. Encher água na chaleira.é uma seqüência finita de instruções. Preparar porta-filtro com filtro sobre o bule. é 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. determina-se os passos seqüenciais para fazer o café: Encher água na chaleira. Por exemplo.. ” Desta foram. observando-se a seqüência proposta..

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

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

12 . é bastante rica em detalhes e.4 apresenta um exemplo do tipo de diagrama de Chapin para o algoritmo de cálculo da média de um aluno. <nome_do_algoritmo> é um nome simbólico dado ao algoritmo com a finalidade de distinguílo dos demais. eventualmente.3 Português Estruturado Esta forma de representação de algoritmos.Exemplo de um diagrama Chapin (Nassi-Schneiderman).4 . N2 Média = (N1+N2)/2 Média >=7? S Escreva “Aprovado” Fim Figura 1. 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. A figura 1. <subalgoritmos> consiste de uma porção opcional do pseudocódigo onde são definidos os subalgoritmos. 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. N Escreva “Aprovado” 1.A figura 1.5 apresenta um exemplo utilizando pseudo-código. 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. por assemelhar-se bastante à forma em que os programas são escritos. Onde: Algoritmo é uma palavra que indica o início da definição de um algoritmo em forma de pseudocódigo.4. De fato. nos subalgoritmos. também conhecida como “portugol” ou pseudo-código. Início Leia N1. encontra muita aceitação. <declaração_de_variáveis> consiste em uma porção opcional onde são declaradas as variáveis globais usadas no algoritmo principal e.

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

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. Desta forma. A principal vantagem é que os programas podem ser compiladas ou interpretadas tornando-os portáveis. acarretando como conseqüência um árduo trabalho na manutenção do código.7 Paradigma de Programação: Programação Estruturada Os recursos computacionais são compostos por hardware e software. possibilita a criação de sub-rotinas que empregam variáveis locais.máquina é complexa para maioria das pessoas. 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. Um compilador lê o programa inteiro e converte-o em um código objeto (código binário ou código de máquina).6 executado. a programação torna-se mais fácil por causa do maior ou menor grau de estruturação de suas linguagens. GPSS (simulação). Dentro deste contexto. 1. Os módulos ou sub-rotinas se interligam através de três mecanismos básicos: 14 . 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. 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. que é uma tradução do código fonte do programa em uma forma que o computador possa executar diretamente. As inovações em hardware permitem desenvolver softwares cada vez mais sofisticados. Softwares sofisticados significam grandes quantidades de linhas de código. As linguagens de alto nível podem se distinguir quanto a sua aplicação em genéricas como C. isto é. LISP (inteligência artificial) ou CLIPPER (banco de dados). a execução do programa depende da presença do interpretador na máquina. A desvantagem é que em geral. A linguagem estruturada tem como característica principal a modularização do código e dos dados. Em geral. 1. isto é. permitindo-se elevar o nível de abstração para o desenvolvimento de soluções mais eficientes. Pascal e Basic ou específicas como Fortran (cálculo matemático).

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

Exemplo de sistema de numeração binária.8.1. uma seqüência de bits de tamanho n pode representar um número inteiro entre -2(n-1) a 2(n-1)-1. O inteiro é representado por uma soma de potências de 2.8). 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.Exemplo notação de complemento de dois.7). cada posição de bit representa uma potência de 2.1 Sistema de Numeração Binária Neste sistema. (00100110)2=(38)10 (-38)10=(11011001)2 Figura 1. a potência de 2 representada por essa posição de bit será incluída na soma porém. Portanto.7 . Portanto. uma seqüência de bits de tamanho n pode representar um número inteiro entre -2(n-1)+1 a 2(n-1)-1.Exemplo de notação de complemento de um. essa potência de 2 não será incluída na soma.1. Se o valor for 1 em determinada posição.8 . uma seqüência de bits de tamanho n pode representar um número inteiro não negativo entre 0 a 2(n-1). Isto significa que o bit da extrema esquerda de um número não é mais usado para representar uma potência de 2. se o valor for 0. (-38)10=(11011001)2 11011001+1=11011010=(-38)10 Figura 1. Portanto. A figura 1.6 apresenta um exemplo.6 . 16 . 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. mas é reservado para o sinal do número. 00100110 1ª posição 2ª posição 5ª posição Figura 1.

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

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

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

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

declaração de constantes. combinadas com a sintaxe formal de C. nomes de variáveis. 2. x). } 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. foram a linguagem de programação C (tabela 2. #include <stdlib. y). Comentários no programa são colocados entre /* e */ não sendo considerados na compilação. Função main(): Variáveis locais e instruções do programa.1).1 Lista de palavras-chave em C ANSI 1. letras maiúsculas e minúsculas são tratadas diferentemente. rótulos. 1. count. Tabela 2. entre outros. Cada instrução encerra com . A forma geral de um programa em C é: Componentes Iniciais: arquivos de cabeçalho. protótipos e variáveis globais. 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. isto é. func(). números ou sublinhados. void func(void).programa principal. funções.h> int x=20. dependendo do compilador utilizado. COUNT.3 Identificadores Identificadores são os nomes usados para referenciar objetos definidos pelos usuário. return(0). Logo. O padrão C ANSI determina que identificadores podem ter qualquer tamanho. } void func(void) { printf(”Fim\n”). printf(“Variável global x=%d\n”. (ponto e vírgula) que faz parte do comando. Por exemplo: int count. porém em geral. Count e COUNT são três identificadores distintos. considera-se apenas os 31 primeiros caracteres. 21 . Count. 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. printf(“Variável y=%d\n”. Em C. O primeiro caractere deve ser uma letra ou um sublinhado e os caracteres subseqüentes devem ser letras.h> #include <stdio.

2).5 Variáveis Variável é uma posição nomeada de memória utilizada para armazenar um valor que pode ser modificado pelo programa.767 a 32.767 -32.535 -32.483.647 a 2.1 Classe de Variáveis As variáveis podem ser declaradas em três lugares básicos: dentro de funções.483. todos os demais tipos básicos podem ter vários modificadores precedendo-os. ou seja.294.535 -32. Exceto o tipo void. Por exemplo: 22 .967.767 a 32. inteiro.5. não o seu tamanho em bytes (tabela 2. int x.4 Tipos de Dados Em C.767 0 a 65. Os modificadores podem ser: signed unsigned long short Tabela 2. 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. O padrão C ANSI estipula apenas a faixa mínima de cada tipo de dado. int. variáveis locais. O tipo void declara explicitamente uma função que não retorna valor algum ou cria ponteiros genéricos.767 a 32. 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.147.2 Tipos de dados definidos no padrão C ANSI.147. ponto flutuante. As variáveis devem ser declaradas da seguinte forma: <tipo> <nome_da_variavel>.767 a 32.295 Seis dígitos de precisão Dez dígitos de precisão Dez dígitos de precisão 2.147. 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. parâmetros formais e variáveis globais. há cinco tipos básicos de dados: caractere.483. 2. respectivamente.2.767 -2.647 -2.767 0 a 65.647 0 a 4. float.147. Em algumas situações é necessário modificar um tipo básico para atender às necessidades de diversas situações.483. double e void.647 a 2. Isto é conseguido através do uso de modificadores que alteram o significado de um tipo básico.

h> float g.1 Atribuição O operador de atribuição pode ser utilizado dentro de qualquer expressão válida em C. } 2.6 Operadores 2. /*c é parâmetro formal*/ int main(void) { float x. 18. 7. Em C. ou seja. 20.1.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. return(0). /*x é variável local*/ x=15. é possível converter os tipos de forma automática. 6.h> #include <stdio.g).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). 9. 5. 16. g=soma10(x). 19. #include <stdlib. Esta conversão é conhecida como conversão de tipos. 15. A atribuição é válida para variáveis de tipos diferentes. 14. /*g é variável global*/ float soma10(float c).6. 12. é permitido atribuição do mesmo valor para muitas variáveis em uma única expressão: var1 = var2 = var3 = expressão. 3. 10.6. 2. 2.6. x = 10. printf(“g=%f”. 4. x = y = z = 0. 13. 11. 17. A forma geral do operador de atribuição é: nome_da_variavel = expressão. 8. porém deve-se observar que poderá ocorrer uma possível perda de informação.

3).6. Falso é zero. O operador lógico refere-se à maneira como essas relações podem ser conectadas. & | ^ ~ >> << AND OR XOR Complemento de um Deslocamento à esquerda Deslocamento à direita Tabela 2. A idéia de verdadeiro e falso é a base dos conceitos dos operadores lógicos e relacionais. 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. 2. 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.5 Bit a Bit A linguagem C oferece um completo conjunto de operadores bit a bit.6. atribuir ou deslocar os bits efetivos em um byte (tabela 2.6 apresenta a tabela verdade dos operadores bit a bit. testar. Tabela 2.5). verdadeiro é qualquer valor diferente de zero. A tabela 2.4 Tabela verdade operadores lógicos. As expressões que usam operadores relacionais ou lógicos devolvem zero para falso e 1 para verdadeiro (tabela 2. A tabela 2.3 Operadores relacionais e lógicos. 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 . Em C.4 apresenta a tabela verdade dos operadores lógicos utilizando 1s e 0s.4 Relacionais e Lógicos O operador relacional refere-se à relação que os valores podem ter uns com os outros. Tabela 2.2.5 Operadores bit a bit.6 Tabela verdade operadores bit a bit. isto é.

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

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

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

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. Calcule e mostre quantos degraus o usuário deverá subir para atingir seu objetivo. calcule e mostre a média ponderada e o conceito que segue a tabela abaixo.0 7. Faça um programa que receba três números e mostre-os em ordem crescente. Faça um programa que receba as três notas. Faça um programa que receba o salário de um funcionário e o percentual de aumento. Cada degrau de uma escada tem X de altura.16. 17.0< media <= 7. A nota final de um estudante é calculada a partir de três notas atribuídas respectivamente a um trabalho de laboratório.0 7. Faça um programa que receba três notas de um aluno. Calcule e mostre: a) O valor (R$) de cada quilowatt.0 <= media <= 8.0 5. 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 <= 6.0. 19.0 6. sem se preocupar com a altura do usuário. 21.0 <= media MENSAGEM Reprovado Exame Aprovado 24. calcule e mostre a médias aritmética e a mensagem que segue a tabela abaixo.0 < media CONCEITO A B C D E 23. Sabe-se que um quilowatt de energia custa um quinto do salário mínimo. MÉDIA PONDERADA 10. calcule e mostre a nota que deverá ser tirada no exame para a aprovação. considerando que a média no exame é 6. calcule e mostre o novo preço sabendo-se que este sofreu um desconto de 10%. 31 . 25. calcule e mostre o salário a receber. 20. a avaliação semestral e a um exame final. Faça um programa que receba dois números e mostre o maior. Faça um programa que receba o preço de um produto. c) O valor (R$) a ser pago com desconto de 15%. 18. 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..0 <= media < 7.0 8. Para alunos de exame. b) O valor (R$) a ser pago por essa residência.0 > media 3. 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 o salário-base de um funcionário. calcule e mostre o valor do aumento e o novo salário. MÉDIA ARITMÉTICA 3.0 < media <= 5.

onde o primeiro representa o dia. Faça um programa que leia um número indeterminado de valores para m. o valor do aumento e seu novo salário. 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. calcule e mostre o novo salário desse funcionário. Menu de opções: 1: Somar dois números 2: Raiz quadrada de um número Digite a opção desejada: 30. todos inteiros e positivos. Deve-se verificar se os três primeiros números estão em ordem crescente 27. Faça um programa que mostre o menu de opções a seguir.00 e R$ 1200. Faça um programa que receba um número inteiro e verifique se esse número é par ou ímpar. o segundo o mês e o terceiro o ano. 31. os quatro números em ordem decrescente. Faça um programa que receba o salário de um funcionário. 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.00 Mais que R$ 600.00 BONIFICAÇÃO 5% 12% Sem bonificação SALÁRIO Até R$ 600.00 R$ 100. 28. 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.00 33. Mostre. um de cada vez.26. em seguida.00 Entre R$ 500. calcule a soma dos números inteiros de 1 até m (m não deve entrar nos cálculos). Elabore um programa que calcule as raízes de uma equação a segundo grau. SALÁRIO Até R$ 500. Cada data deve ser fornecida por três valores inteiros. verifique quantos divisores possui.00 Acima de R$ 1200. Se m for par. Mostre os cálculos realizados. receba a opção do usuário e os dados necessários para executar cada operação. Faça um programa que determine a data cronologicamente maior de duas datas fornecidas pelo usuário. 2 = −b± ∆ 2*a 29. f ( x) = a * x 2 + b * x + c f ( x) = 0 ∆ = b2 − 4 * a * c x1. acrescido de bonificação e de auxílio-escola. 32 . Se m for ímpar.00 AUXÍLIO-ESCOLA R$ 150.

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

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

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

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

a matriz que se obtém trocando ordenadamente as linhas pelas colunas chama-se transposta de A. B e C e calcule a área do triângulo. Dada uma matriz A(mxn). portanto. ATENÇÃO: Se a determinante D=0 então os três pontos não formam um triângulo. 37 .programa que receba as coordenadas dos vértices A. Elabore um programa que imprima os elementos da diagonal principal de qualquer matriz mxm. e é indicada por At (ou por At). 21. os elementos aij tais que i=j formam o que chamamos de diagonal principal da matriz. Elabore um programa que receba uma matriz A(3x2) e crie a matriz At. 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. Numa matriz quadrada.

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

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

printf("Ola %s!\n". printf("Digite seu nome: "). As variáveis são denominadas membros da estrutura. ESTRUTURAS. 13. y. A declaração de variáveis do tipo estrutura pode ser realizada da seguinte maneira: struct cliente { char nome[41]. printf("Ola %s!\n". int main(void) { x=&y.. 4.nome). 8. 6. A palavra struct define uma declaração. sobrenome[41]. 2.nome). 17. Uniões.h> struct cliente { char nome[41]. <tipo> <variável_n>. cliente *x. printf("Digite seu nome: "). 23. Enumerações. Em C é declarada uma estrutura da seguinte maneira: struct <nome_da_struct> { <tipo> <variável_1>. 40 . 9. &x->nome).. scanf("%s". 11. struct { char char }. 22. y. 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>.nome). <tipo> <variável_2>. struct cliente nome[41].1 Estruturas Estrutura (structure) é um tipo de dado formado por um conjunto de variáveis referenciadas por um nome.nome). ENUMERAÇÕES E UNIÕES A linguagem C permite criar tipos de dados utilizando: • • • Estruturas.<membro> <nome_da_estrutura>-><membro> 14. 21. }. char sobrenome[41]. seguida do nome da estrutura e das respectivas variáveis delimitadas pelas chaves. &z[0]. printf("Digite seu nome: "). 18. y. 20. }.7. &y. . 7. 3.. return(0). z[0]. 7.h> #include <stdio. 15. y. 5. z[5]. . z[5]. #include <stdlib. char sobrenome[41]. 19. 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. }*x. 16.. } Exemplo: 1. char sobrenome[41]. 12. scanf("%s". 10. z[5]. scanf("%s". struct cliente { char nome[41]. x->nome). }*x. printf("Ola %s!\n".

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Elabore uma função que receba uma palavra (string) e retorna a quantidade de caracteres. Elabore uma função que receba 10 números reais e retorna a média aritmética. for(i=0. } 10. 5. i++) printf("%d\n".h): void randomize(void). 4. 10. int rand(void). 8. 7. 3. Elabore uma função que aceita como parâmetro dois números reais e retorna a média aritmética. µ= ∑X i =1 n i n 8. Elabore uma função que aceita como parâmetro dois catetos e retorna o valor da hipotenusa.8 Exercícios 1. 56 . A função randomize() inicia a geração de números aleatórios. retornando o valor do desvio padrão. Elabore uma função que receba 10 números reais e a média. 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. randomize(). rand() % 100). 3. 6. 13. Sintaxe (time. 11.h> int main(void) { int i. printf("Dez números randômicos de 0 a 99\n\n"). 6.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. 12. Elabore uma função que receba uma string e troque todos os caracteres ‘a’ por ‘@’.DEF . 4.10. 1. #include <stdlib. 9. 7.h> #include <time. i<10.h> #include <stdio.h e stdlib.7 Outras Funções Função randomize() e rand(): A função rand() devolve um número aleatório entre 0 e RAND_MAX. return(0). ABC. 2. Elabore uma função que aceita como parâmetro 5 números reais e retorna o maior número. A constante RAND_MAX é definida na biblioteca <stdlib. 2.h>.

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

dado o centro C e a distância r. a relação entre x e y é dada pela equação abaixo (equação da circunferência). 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.18. apresentem a equação da circunferência. Dado um ponto C e uma distância r. e verificar se a circunferência passa pela origem. y) é um ponto qualquer da circunferência. os pontos em que a circunferência corta o eixo Ox e Oy. Se P(x. 58 .

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. para o armazenamento da informação. Existem duas maneiras fundamentais de um programa alocar memória do computador. 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. size_t size). 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.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 figura 11. que é fixo durante todo o tempo de execução do programa. um programa em execução pode. cada variável recebe um endereçamento de memória e o respectivo tamanho. void *malloc(size_t size). O armazenamento é realizado em uma região de memória livre. sempre que necessário e houver a disponibilidade de espaço em memória. A segunda forma é através da alocação dinâmica. ou heap. Para este tipo de alocação necessita-se definir de antemão a quantidade de armazenamento necessária. A primeira forma é através de variáveis locais e globais (alocação estática). void *calloc(size_t num. A alocação dinâmica é o processo de alocar espaço de memória do computador em tempo de execução. solicitar a alocação do espaço e utilizar convenientemente os dados.1 Utilização da memória de um programa. 59 . Pilha Heap Variáveis Globais Código do Programa Figura 11. ALOCAÇÃO DINÂMICA Um programa necessita de memória para armazenar informações.11. isto é. ou seja.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4). 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ó.3 Listas Ligadas São estruturas de armazenagem e recuperação de dados de forma randômica. A B Figura 14. 14.4 Ilustração de uma fila circular. 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. 74 . A adição de um nó pode ser realizada no início ou ao longo de uma lista ligada. o elo proximo se torna um ponteiro para o primeiro nó da lista.qualquer número de itens poderia ser colocado na fila.3. isto é. uma lista encadeada. 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. As listas encadeadas podem ser singularmente (simples) ou duplamente encadeadas. 14. 14. A adição de um nó no início de uma lista ligada é realizada em quatro etapas: a) Um nó vazio é criado. o valor corrente de topo.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. b) O campo info do nó é inicializado com um valor em particular.

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. 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) Ao determinar a posição de inserção. mas esse fato tem que ser refletido no valor do Primeiro. 1 2 5 8 4 Primeiro Figura 14. o ponteiro Primeiro deve ser atualizado. c) Percorre a lista comparando o campo info do novo nó com cada nó da lista.5 Ilustração de uma lista singularmente ligada. A A A Primeiro (1) Tmp Primeiro (2) Tmp Primeiro (3) 75 . O processo de adicionar um novo nó ao longo da lista de forma ordenada é realizada em quatro etapas: a) Um nó vazio é criado. 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. b) O campo info do nó é inicializado com um valor em particular. Consequentemente. Deve-se observar que: a) Não se pode remover um nó de uma lista vazia. c) A remoção do primeiro nó da lista com pelo menos dois nós exige a atualização do ponteiro Primeiro. o ponteiro Primeiro é atualizado para se tornar o ponteiro para o novo nó. b) A remoção de um único nó de uma lista ligada de apenas um nó.d) O novo nó precede todos os nós da lista. o elo proximo do anterior do nó corrente aponta para o novo nó e. o elo proximo do novo nó aponta para o elo proximo do nó corrente.

C A C A C A Tmp (1) Primeiro Tmp (2) Primeiro Primeiro (3) Figura 14.6 Ilustração de inserção em 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 .Figura 14.

a lista pode ser reconstruída utilizando-se o outro elo. 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). c) O elo proximo apontado por Ultimo recebe novo nó.3. no meio da lista. 77 . b) O elo anterior do novo nó recebe Ultimo.Figura 14. no fim da lista. Se um dos elos tornar-se inválido.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. c) O elo anterior apontado por Primeiro recebe novo nó. d) O ponteiro Primeiro recebe novo nó.8 Ilustração de inserção em uma lista singularmente ligada. 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ó. 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). 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). A vantagem de possuir dois elos são: • • A lista pode ser lida em ambas as direções. 1 9 3 5 Primeiro Último Figura 14. 14. b) O elo proximo do novo nó recebe Primeiro.8 Ilustração de uma lista linear duplamente ligada.

78 . c) Percorre a lista comparando o campo info do novo nó com cada nó da lista. o elo proximo do anterior do nó corrente aponta para o novo nó. 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 anterior do nó corrente aponta para o novo nó. O elo proximo do novo nó aponta para o nó corrente e. A operação de remoção consiste em remover um nó do início. Deve-se observar que: a) Não se pode remover um nó de uma lista vazia. O elo anterior do novo nó aponta para o anterior do nó corrente. do fim ou ao longo da lista e retornar o valor armazenado nela.9 Ilustração de inserção em uma lista duplamente ligada.b) O campo info do nó é inicializado com um valor em particular. d) Ao determinar a posição de inserção.

14. para cada 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. 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. c) A remoção do primeiro nó da lista com pelo menos dois nós exige a atualização do ponteiro Primeiro. Árvore binária são árvores de grau 2.9 Ilustração de uma lista circular duplamente ligada com cabeçalho. 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. Os outros nós são chamados de nó interno. 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 . O nível do nó raiz é 0. O número de subárvores de um nó é chamado grau daquele nó. d) A remoção do ultimo nó da lista com pelo menos dois nós exige a atualização do ponteiro Ultimo. Se um nó está no nível i então a raiz de suas subárvores estão no nível i+1. o ponteiro Primeiro e Ultimo deve ser atualizado. subárvore esquerda e subárvore direita. Em cada nó contém um registro. Um nó de grau zero é chamado de nó externo ou folha.b) A remoção de um único nó de uma lista ligada de apenas um nó. Grau de uma árvore é o mais alto dentre os graus de seus nós. e. Cada elemento de uma árvore binária é chamado nó da árvore.

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

Elaborar um programa que simule o armazenamento e recuperação de uma pilha.Figura 14. Elaborar as funções pop() e push() de uma pilha. 14. 3. 81 . Elaborar as funções para armazenar e recuperar dados em uma fila. 2. 4.5 EXERCÍCIOS 1. Elaborar um programa que simule uma fila de atendimento.11 Exemplo de árvore binária. 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.

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

16. APÊNDICE 16.1 Tabela ASCII 83 .

um sistema de 12 unidades para os meses e um sistema de 10 unidades para os anos. 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. É um sistema muito utilizado na área de microprocessadores. Para a representação de quantidades maiores que a base adota-se pesos para cada posição do algarismo. surgiu a necessidade de medir grandezas.2 Sistema Numérico O homem é resultado contínuo da sua própria evolução. É um sistema muito utilizado em circuitos lógicos e aritméticos. isto é. Por exemplo. por 3 milhares. 5 dezenas e 2 unidades. Em um determinado momento ao longo desse processo. 4 centenas. 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. 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. 84 . b = base do número.16. o número 3452 é composto 4 algarismos. 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. n = quantidade de algarismos –1. um sistema de 60 unidades para minutos e segundos. o tempo é medido utilizando um sistema de 24 unidades para as horas. Para medir essas grandezas o homem criou os sistemas numéricos. Utiliza 10 símbolos (algarismos) para representar qualquer quantidade: 0 1 2 3 4 5 6 7 8 9. Por exemplo. Cada algarismo ou dígito de um número binário é chamado de bit (binary digit).

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... para obter o equivalente em uma base b qualquer. 16... correspondem ao número na base b.. 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. Hexadecimal 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 .. tomados na ordem inversa.Equivalência entre os sistemas numéricos. Binário 0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000 10001 . (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 .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.1 .

750 0.1)16 0.0625)10 = (25. 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.375)10 = (1000. (8.375 * 2 = 0. (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. A parte fracionária é utilizado o processo das multiplicações sucessivas pela base desejada.375)10 = (?) 2 (8)10 = (1000) 2 0.750 * 2 = 1.500 0.011) 2 86 . A parte inteira resultante dos produtos formará os dígitos da parte fracionária do número convertido. a parte inteira é convertida separadamente pelo processo das divisões sucessivas.0625)10 = (?)16 (37)10 = ( 25)16 0. Para a conversão de base 10 para base 2 ou base 16.500 * 2 = 1.000 → Fim (8.0625 *16 = 1 → 1 0. n = quantidade de algarismos da parte inteira –1.000 →0 →1 →1 (37. m = quantidade de algarismos da parte fracionária. Esta relação vem do fato que o número 16 pode ser escrito como 24. b = base do número.Existem uma relação estreita entre o sistema binário e o hexadecimal.000 → Fim (37.

Sign up to vote on this title
UsefulNot useful