MAUÁ
Computação I
ECA301
•
• Informações sobre o Curso
• Programa da Disciplina
• Cronograma de Aulas
• Introdução à Programação em Linguagem C
•
Prof. Marcio Vieira Soares
Prof. Wilson Inacio Pereira
Fevereiro, 2006
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Apostila ECA301 2006, Notas de estudo de Mecatrônica
Apostila de introdução a programação em C
Tipologia: Notas de estudo
Antes de 2010
1 / 139
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe Apostila ECA301 2006 e outras Notas de estudo em PDF para Mecatrônica, somente na Docsity!
MAUÁ
Computação I
ECA
• Informações sobre o Curso
• Programa da Disciplina
• Cronograma de Aulas
• Introdução à Programação em Linguagem C
Prof. Marcio Vieira Soares
Prof. Wilson Inacio Pereira
Fevereiro, 2006
I
- 1 - Conceitos básicos............................................................................................. Índice
- 1.1 Paradigmas de programação
- 1.1.1 Programação não-estruturada
- 1.1.2 Programação estruturada
- 1.1.3 Programação orientada a objetos e eventos..........................................................................................
- 1.2 Linguagens de programação.......................................................................................
- 1.2.1 Linguagens de baixo e alto nível...........................................................................................................
- 1.2.2 Vantagens e desvantagens
- 1.2.3 Compiladores e interpretadores............................................................................................................
- 1.3 Metodologia Top-Down
- 1.4 A linguagem C
- 2 - Expressões, entrada e saída de dados .......................................................
- 2.1 O programa principal................................................................................................
- 2.2 Variáveis....................................................................................................................
- 2.2.1 Declaração de variáveis.......................................................................................................................
- 2.3 Entrada e saída de dados..........................................................................................
- 2.3.1 Exibição de dados usando a função printf
- 2.3.2 Leitura de dados usando a função scanf
- 2.4 Expressões de atribuição
- 2.4.1 Atividade
- 2.5 Operadores
- 2.5.1 Operadores aritméticos
- 2.5.2 Operadores relacionais
- 2.5.3 Operadores lógicos...............................................................................................................................
- 2.5.4 Operadores de atribuição aritmética
- 2.5.5 Atividades
- 3 - Diretivas e estruturas condicionais ..........................................................
- 3.1 Diretivas de compilação
- 3.1.1 Diretiva #include
- 3.1.2 Diretiva #define
- 3.2 Estruturas condicionais
- 3.2.1 Atividades
- 3.2.2 Operador condicional ternário
- 3.2.3 Atividade
- 3.2.4 Comando switch
- 3.2.5 Atividade
- 4 - Estruturas repetitivas ..................................................................................
- 4.1 Estrutura while
- 4.1.1 Atividades
- 4.2 Estrutura do-while
- 4.2.1 Atividades
- 4.3 Estrutura for II
- 4.3.1 Atividades
- 5 - Funções ............................................................................................................
- 5.1 Funções de biblioteca
- 5.2 Funções criadas pelo programador...........................................................................
- 5.2.1 Retorno de valores
- 5.2.2 Protótipos
- 5.3 Passagem de parâmetros por valor e por referência
- 5.4 Bibliotecas e arquivos de cabeçalho
- 5.4.1 Exemplo
- 5.4.2 Atividades
- 6 - Variáveis indexadas ......................................................................................
- 6.1 Variáveis indexadas unidimensionais – vetores
- 6.1.1 Acesso aos elementos de um vetor
- 6.1.2 Atividade
- 6.1.3 Vetores como parâmetros de funções..................................................................................................
- 6.1.4 Atividade
- 6.2 Variáveis indexadas bidimensionais – matrizes
- 6.2.1 Acesso aos elementos de uma matriz..................................................................................................
- 6.2.2 Atividade
- 6.2.3 Matrizes como parâmetros de funções................................................................................................
- 6.2.4 Atividades
- 6.3 Vetores e strings
- 7 - Estruturas........................................................................................................
- 7.1 Definição e declaração...............................................................................................
- 7.2 Acesso aos membros..................................................................................................
- 7.3 Estruturas aninhadas
- 7.4 Estruturas e funções
- 7.4.1 Atividades
- 7.5 Alocação de memória.................................................................................................
- 7.5.1 Atividade
- 7.6 Tipos de dados definidos pelo programador.............................................................
- 7.7 Tipos abstratos de dados...........................................................................................
- 7.7.1 Exemplo de aplicação
- 8 - Ponteiros..........................................................................................................
- 8.1 Ocupação de memória
- 8.2 Declaração de ponteiros
- 8.3 Acesso a um endereço
- 8.4 Acesso indireto
- 8.5 Aritmética de ponteiros
- 8.6 Ponteiros e funções....................................................................................................
- 8.6.1 Atividade
- 8.7 Ponteiros e vetores
- 8.8 Ponteiros, vetores e funções...................................................................................... III
- 8.9 Ponteiros e strings
- 8.9.1 Atribuições e comparações entre strings
- 8.9.2 Atividades
- 8.10 Ponteiros para estruturas.........................................................................................
- 8.11 Estrutura da memória
- 8.12 Alocação dinâmica de memória
- 8.12.1 Liberação da memória
- 8.12.2 Atividade
- 8.13 Ponteiros e matrizes..................................................................................................
- 8.13.1 Ponteiros, matrizes e funções..............................................................................................................
- 8.13.2 Atividade
- 8.14 Ponteiros para ponteiros...........................................................................................
- 9 - Arquivos ...........................................................................................................
- 9.1 Arquivos-texto: abertura e fechamento....................................................................
- 9.1.1 Atividade
- 9.2 Gravação de caracteres
- 9.2.1 Atividade
- 9.3 Leitura de caracteres
- 9.4 Detecção de fim de arquivo
- 9.5 Verificação de erros
- 9.5.1 Atividade
- 9.6 Gravação e leitura de strings
- 9.7 Arquivos binários
- 9.7.1 Atividade
- 9.7.2 Atividade
- 9.8 Acesso aleatório
- 9.8.1 Atividade
- 9.8.2 Posicionamento do indicador de arquivo
- 9.9 Descarga de dados.....................................................................................................
- 9.9.1 Limpeza do buffer do teclado...............................................................................................................
- 9.10 Atividade – exemplo de aplicação.............................................................................
- 10 - Listas.................................................................................................................
- 10.1 Listas simplesmente ligadas
- 10.1.1 Criação da lista
- 10.1.2 Exibição da lista
- 10.1.3 Programa principal............................................................................................................................
- A função DestroiLista libera toda a memória alocada para a lista antes que o programa termine:
- 10.1.4 Inserção de elementos
- 10.1.5 Remoção de elementos da lista
- 10.1.6 Atividades
- 10.2 Listas duplamente ligadas......................................................................................
- 10.2.1 Implementação
- 10.2.2 Inserção de elementos
- 10.2.3 Atividade
- 10.2.4 Remoção de elementos da lista
- 10.2.5 Atividade IV
- 10.3 Ordenação................................................................................................................
- 10.4 Atividade – exemplo de aplicação...........................................................................
- 11 - Grafos .............................................................................................................
- 11.1 Conceitos sobre grafos.............................................................................................
- 11.1.1 Representação matemática
- 11.1.2 Representação computacional...........................................................................................................
- 11.1.3 Atividade
- 11.2 Dígrafos....................................................................................................................
- 11.2.1 Representação matemática
- 11.2.2 Representação computacional...........................................................................................................
- 11.3 Redes........................................................................................................................
- 11.3.1 Representação computacional...........................................................................................................
- 11.3.2 Atividade - Rede PERT......................................................................................................................
- 11.4 Árvores.....................................................................................................................
- 11.4.1 Árvores binárias
- 11.4.2 Representação computacional...........................................................................................................
- 11.4.3 Atividades
- 11.5 Aplicações
- 11.5.1 Pesquisa Operacional - Problema de transporte
- 11.5.2 Inteligência Artificial - Missionários e canibais...............................................................................
- 11.5.3 Análise de expressões
Computação I – ECA301 (2006) Informações sobre o curso
A média de aproveitamento (MA) será calculada pela expressão:
2MS1 3MS
MA
em que MS1 e MS2 representam as médias de trabalhos do primeiro e segundo semestre, calculadas pela média aritmética simples das notas de trabalho de cada um dos semestres. De acordo as normas vigentes na EEM:
- se MA ≥ 6,0 o aluno está aprovado;
- se MA <3,0 o aluno está reprovado;
- se 3,0 ≤ MA < 6,0 o aluno poderá realizar a prova de Exame Final.
5. Bibliografia
Literatura indicada
- SOARES, M. V.; PEREIRA, W. I., Computação para automação; introdução à programação em linguagem C. São Caetano do Sul, SP: EEM, 2002 103p.
- ZIVIANI, N., Projeto de Algoritmos; com implementações em Pascal e C. São Paulo, SP: Pioneira Thomson, Learning, 1998.
- WIRTH, N., Algoritmos e Estruturas de Dados, Rio de Janeiro, RJ: LTC, 1999 255p.
- KNUTH, D. E. The Art of Computing Programming: Addison Wesley, 1973.
- SOUZA, M. A. F., SOARES, M. V., GOMES, M. M., CONCILIO, R., Algoritmos e Lógica de Programação, São Paulo, Pioneira Thomson Learning, 2005 214p.
- SCHILDT, H., C Avançado, guia do usuário: McGraw-Hill, São Paulo, 1989. 335p.
- KRUSE, R. L., Data structures and program design in C. Englewood Cliffs, NJ: Prentice-Hall, 1991 525p.
Literatura adicional
- MIZRAHI, V. V., Treinamento em linguagem C. São Paulo, SP: McGraw-Hill, 1990.
- ROBERTS, E. S., The art and science of C; a library-based introduction to computer science. Reading: Addison-Wesley, 1995 704p.
- FURTADO, A. L., Teoria dos grafos; algoritmos. Rio de Janeiro, RJ: LTC, 1973 155p.
6. Aulas
- É considerado dever do aluno trazer o material indicado e as anotações de aula já utilizados no curso para consulta;
- as aulas serão iniciadas pontualmente no horário especificado pela EEM. Evite chegar atrasado, pois isto pode fazer com que o seu professor não permita a sua entrada na sala. Neste caso, certamente haverá perda de conteúdo da matéria e de nota;
- alunos de outras turmas que por um motivo qualquer participarem de aula fora do seu horário, não receberão nota nas atividades desenvolvidas pela disciplina nessa aula;
- não haverá reposições individuais de trabalhos ou atividades. O aluno que faltar a uma determinada aula só poderá repô-la, se houver condições, durante a semana de realização. Em caso contrário, a nota do aluno para a aula perdida será zero;
- aulas que não tenham sido ministradas por motivos de força maior poderão ser repostas em datas estabelecidas pela coordenação da disciplina, se necessário;
Computação I – ECA301 (2006) Informações sobre o curso
- as atividades realizadas durante as aulas poderão ser individuais ou em grupos, formados por quaisquer alunos da sala, conforme a orientação do professor. A cada aula será atribuída uma nota máxima, de acordo com a coordenação da disciplina;
- os grupos, ou alguns alunos dos grupos, poderão ser sorteados para uma apresentação à sala sobre a atividade solicitada. Existe a possibilidade de solicitação de entrega de uma atividade em aula posterior à sua apresentação.
Compilador C
O compilador utilizado no curso é o Dev-C++ (versão 4.9.9.2), disponível para download gratuito no endereço http://www.bloodshed.net/devcpp.html. Para uso doméstico, o aluno poderá utilizar qualquer compilador C/C++ compatível com o padrão ANSI.
Atividades em laboratório
- O laboratório deve sempre ser mantido em ordem. Não será permitido atender telefonemas, alimentar-se ou fazer trabalhos de outras disciplinas durante as aulas;
- a responsabilidade pela manutenção dos computadores do laboratório é do Núcleo de Métodos Computacionais (NMC) da escola. Problemas com os computadores ou com outros equipamentos devem ser relatados ao professor o mais rápido possível;
- ao final de cada aula os computadores deverão ser preparados para uso da próxima turma ou desligados no caso da última aula do dia. Estas ações devem ser executadas a partir do menu Start do Windows. As mesas de trabalho devem ser desocupadas e as cadeiras, duas por computador, devem ser colocadas nos devidos lugares;
- recomenda-se trazer um disquete para armazenar os códigos desenvolvidos ao longo do ano, bem como um caderno para anotações.
Avaliação dos trabalhos
- Trabalhos iguais receberão nota zero, independentemente de quem forneceu ou recebeu;
- as atividades não entregues na data estipulada serão punidas com a redução de 1, ponto por dia de atraso na sua nota final, incluindo-se os sábados;
- as notas de trabalho serão revistas durante as aulas, sem a necessidade de solicitação formal.
7. Apoio a Distância
A disciplina utilizará o suporte de um ambiente de Educação à Distância (EaD) acessível pelo endereço www.ead.maua.br. Nele serão realizadas interações com os alunos a partir de listas de discussão, fóruns e atividades que serão utilizadas para geração de parte das notas de trabalho.
8. Comunicações
Existe um formulário eletrônico para comunicações na página da disciplina, hospedada no website do IMT (www.maua.br/cursos). Sugere-se também que o aluno acesse, sempre que possível, o sistema de Educação à Distância, pois nele serão divulgados avisos e informações importantes para o acompanhamento do curso.
Documento atualizado em 10.02.
Computação I – ECA301 (2006) Informações sobre o curso
Cronograma de aulas (continuação)
Aula 14 : Semana 31 (de 01.08 a 05.08) Listas ligadas I
- Revisão de conteúdo
- Listas simplesmente ligadas
Aula 15 : Semana 32 (de 07.08 a 12.08) Listas ligadas II
- Listas duplamente ligadas
- Distribuição do Estudo de Caso 06
Aula 16 : Semana 33 (de 14.08 a 19.08) Estruturas dinâmicas de dados
- Listas ligadas: aplicações
- Filas e pilhas
Aula 17 : Semana 34 (de 21.08 a 26.08) Grafos
- Resolução do Estudo de Caso 06
- Grafos, redes e árvores
Aula 18 : Semana 35 (de 28.08 a 02.09) Árvores binárias
- Árvores binárias
- Aplicações
3º Bimestre
Semana 36 (de 04.09 a 09.09) Não haverá aula
Aulas suspensas – 3ª prova de 2006
Aula 19 : Semana 39 (de 25.09 a 30.09) Otimização em redes
- Revisão de conteúdo
- Algoritmos de otimização em redes
- Distribuição do Estudo de Caso 07
Aula 20 : Semana 40 (de 02.10 a 07.10) Tópicos em programação
- O Problema da Atribuição
- Resolução do Estudo de Caso 07
Semana 41 (de 09.10 a 14.10) Não haverá aula
Aula 21 : Semana 42 (de 16.10 a 21.10) Noções de Inteligência Artificial I
- Noções de Inteligência Artificial
- Distribuição do Estudo de Caso 08
Aula 22 : Semana 43 (de 23.10 a 28.10) Noções de Inteligência Artificial II
- Noções de Inteligência Artificial
- Resolução do Estudo de Caso 07
4º Bimestre
Semana 44 (de 30.10 a 04.11) Não haverá aula
Aulas suspensas – 4ª prova de 2006
ECA301 – Computação I (2006) 1 – Conceitos básicos
1 - Conceitos básicos
Neste capitulo serão discutidos os principais paradigmas de programação e sua relação com os tipos de linguagens de programação existentes. Ao final do capítulo, serão comentadas as principais características da linguagem C, linguagem a ser usada no curso.
1.1 Paradigmas de programação
Paradigmas de programação são modelos, padrões ou estilos de programação, suportados por linguagens que agrupam certas características comuns.
1.1.1 Programação não-estruturada
É um modo de programação essencialmente seqüencial com o uso de desvios controlados ou incondicionais, que permitem a simulação de estruturas de programação e sub-rotinas. Linguagens não-estruturadas são usadas em situações didáticas (Basic) ou para programação específica em baixo nível ( Assembly ). Programas não-estruturados são extremamente flexíveis, mas de difícil manutenção pela existência dos desvios.
1.1.2 Programação estruturada
A forma mais difundida de programar computadores, e que deu origem a linguagens como C e Pascal é um paradigma centrado no conceito de variáveis e comandos. Neste paradigma, os programas são decompostos em passos de processamento que usam sub-rotinas ou procedimentos, o que faz com que também seja chamado de paradigma procedural.
Uma grande vantagem da programação estruturada sobre a não-estruturada é o alto índice de reaproveitamento de código, já que as sub-rotinas podem ser agrupadas em bibliotecas e utilizadas por outros programas. O uso de sub-rotinas também se presta à modularização e encapsulamento funcional.
O paradigma da programação estruturada tem base no Teorema de Bohm e Jacopini, que afirma que qualquer programa pode ser criado a partir de três tipos de estruturas de programação: seqüencial, condicional e repetitiva.
1.1.3 Programação orientada a objetos e eventos
Trata-se de um paradigma que procura modelar computacionalmente objetos do mundo real. Para isso, utiliza o conceito de classes , definindo um programa como um conjuntode objetos (instâncias das classes), cada um com suas propriedades e métodos. É talvez o paradigma de maior expressão no mercado atual, implementado em linguagens como C++, Java e Object Pascal, usada no ambiente Delphi.
As classes e os objetos constituem uma forma de se encapsular informações e comandos em uma única estrutura, criando camadas de proteção aos dados e permitindo que se faça deles uma ramificação posterior ( herança ). Enquanto os outros paradigmas dão maior ênfase às ações do programa, deixando os dados em segundo plano, este busca tratar ambos com o mesmo grau de importância. Com isto, o índice de reaproveitamento de código se torna muito maior, permitindo o desenvolvimento mais rápido de aplicativos grandes e complexos.
1.2 Linguagens de programação
Um programa de computador é um conjunto instruções que representam um algoritmo para a resolução de um determinado problema. Essas instruções devem ser escritas por meio de um conjunto de símbolos e palavras, cujas regras de estruturação lógica e sintática formam uma linguagem de programação.
ECA301 – Computação I (2006) 1 – Conceitos básicos
programação e seu conteúdo não pode ser alterado. Os interpretadores , por outro lado, traduzem e executam instruções isoladas ou pequenos grupos de instruções por vez, dentro de um ambiente de programação. O interpretador precisa estar presente a cada execução do programa-fonte para a checagem da sintaxe e conversão do código.
Toda linguagem de alto nível precisa ter seu próprio compilador ou interpretador para um determinado computador ou família de computadores. Por exemplo, programas em linguagem Java se servem de uma máquina virtual, conhecida como Java Virtual Machine , que é, na prática, um interpretador desenvolvido para o hardware em que o programa irá rodar. A portabilidade do código Java é oriunda desta máquina virtual. Para o caso de programas compilados, o arquivo executável deve ser criado (compilado) especificamente para a plataforma desejada.
1.3 Metodologia Top-Down
Em programas complexos é desejável que a rotina principal não seja muito extensa, contendo apenas chamadas a sub-rotinas que indiquem, em linhas gerais, a utilidade do programa. Esta abordagem, implementada pela técnica Top-Down , facilita a interpretação de como um programa funciona e permite que se identifique com facilidade em que ponto do código pode haver algum problema.
Nesta técnica, o problema original é dividido em pequenas partes que possam ser facilmente entendidas e resolvidas. Este processo inicial de análise permite a resolução de um problema complexo, separando-o em soluções mais simples. Em uma segunda etapa, faz-se o processo inverso, realizando uma síntese da solução final a partir das soluções separadas.
A técnica Top-Down possui este nome porque analisa primeiramente um problema como um todo (Top), identificando a seguir uma primeira divisão deste em subproblemas menores (Down). O processo é realizado desta forma até que não seja mais necessária nenhuma subdivisão.
1.4 A linguagem C
A linguagem C é uma linguagem estruturada genérica de alto nível^1 , criada por (e para) programadores, tendo como metas principais a flexibilidade e a portabilidade. Por ter nascido juntamente com o advento da teoria de linguagem estruturada e do computador pessoal, é uma linguagem que se tornou rapidamente popular entre os programadores. Foi usada para desenvolver o sistema operacional UNIX, e, mais recentemente, as linguagens C++ e Java. Algumas características da linguagem C:
- Gera programas pequenos e eficientes;
- É praticamente independente da máquina;
- Inclui características de baixo nível geralmente disponíveis apenas em Assembly;
- Encontra compiladores para praticamente todas as plataformas de hardware;
A linguagem C foi desenvolvida nos anos 80 por Dennis Ritchie nos laboratórios da Bell Telephones Inc. como uma ramificação das linguagens BCPL e B. Seu uso ficou restrito à Bell até 1978 quando, juntamente com Brian Kernighan, Ritchie publicou uma descrição da linguagem, conhecida como K&R C.
(^1) Alguns autores classificam a linguagem C como sendo de médio nível , por combinar elementos de linguagens
de alto nível – estruturação, compartimentalização – com a funcionalidade da linguagem Assembly.
ECA301 – Computação I (2006) 1 – Conceitos básicos
As características de portabilidade e estruturação da linguagem tornaram-na muito popular: diversos compiladores e interpretadores C foram escritos para computadores de todos os tamanhos e muitas aplicações comerciais foram desenvolvidas. Além disso, muitos softwares escritos originalmente em outras linguagens foram reescritos em C, como o sistema operacional Unix, escrito originalmente em Assembly.
A maioria das implementações comerciais de C criadas inicialmente diferia ligeiramente da definição original de Kernighan e Ritchie, gerando incompatibilidades e diminuindo a portabilidade que a linguagem tentou oferecer. Como conseqüência disso, o American National Standards Institute (ANSI) iniciou, em 1983, um trabalho de padronização da linguagem C cujo resultado é conhecido hoje como ANSI C. Atualmente, todos os compiladores e interpretadores comerciais adotam o padrão ANSI, além de oferecer recursos adicionais próprios.
Em 1990 a Borland International Co ., fabricante de compiladores profissionais, escolheu as linguagens C e Pascal como linguagens de trabalho para seus ambientes integrados de desenvolvimento, o Turbo C e o Turbo Pascal. Em 1992, C tornou-se ponto de concordância entre teóricos do desenvolvimento da teoria de programação orientada a objetos, o que resultou na criação da versão orientada a objetos de C, conhecida como C++.
ECA301 – Computação I (2006) 2 – Expressões, entrada e saída de dados
Tipo Espaço ( bytes ) Armazenamento char 1 -128 a 127 unsigned char 1 0 a 255 int 4 -2.147.483.648 a 2.147.483. unsigned int 4 0 a 4.294.967. short int 2 -32.768 a 32. unsigned short int 2 0 a 65535 long int 4 idem a int unsigned long int 4 idem a int long long int 8 Ver a seguir float 4 ± 1,17.10 -38^ a ± 3,40.10 38 double 8 ± 2,22.10 -308^ a ± 1,79.10 308 long double 12 ± 2,22.10 -4932^ a ± 1,79.10 4932
Tabela 2.1: espaço de memória ocupado por variáveis
O tipo de dados long long int é um tipo inteiro de 8 bytes , suportado por alguns compiladores (como o Dev-C++). A faixa de armazenamento desse tipo de dados (com sinal) é de -9.223.372.036.854.775.808 a 9.223.372.036.854.775.807 ou de 0 a 2 64 (sem sinal).
2.2.1 Declaração de variáveis
A declaração de variáveis é feita sempre no início de um bloco de código, usando-se o nome do tipo de dados seguido pelo nome da variável ou por uma lista de nomes de variáveis. Exemplos:
int x,y; float a,b,c = 2.2; char opcao;
Uma variável declarada no corpo de uma função é uma variável local , reconhecida apenas pela função. Uma variável declarada fora do corpo de uma função é global , sendo reconhecida por todas as funções que estiverem após o ponto em que for feita a declaração.
Os nomes dados às variáveis e funções de um programa, chamados de identificadores , devem respeitar regras básicas, comuns à maioria das linguagens de programação: iniciar sempre por um caractere ou sublinhado, não conter espaços ou caracteres acentuados, etc.
2.3 Entrada e saída de dados
Ao contrário da maioria das linguagens de programação, a linguagem C não possui comandos internos para entrada e saída de dados, dependendo de funções de biblioteca. A maneira mais simples de realizar entrada e saída de dados em linguagem C é pelo uso das funções genéricas scanf e printf.
A linguagem C é sensível à caixa, ou seja, identificadores como nome e Nome representam variáveis ou funções diferentes. Além disso, existem palavras de uso reservado que não podem ser usadas como identificadores (ver Apêndice 6).
ECA301 – Computação I (2006) 2 – Expressões, entrada e saída de dados
2.3.1 Exibição de dados usando a função printf
A função printf , definida no arquivo de cabeçalho^2 stdio.h , imprime valores de uma lista de argumentos, formatados de acordo com uma string de controle, que pode incluir textos estáticos e especificadores de formatação. Exemplo:
printf("Valor da área = %f",A);
Esta instrução exibe na tela a frase " Valor da área = " (sem as aspas), seguida pelo valor armazenado na variável A , formatado como um número em ponto flutuante pelo especificador de formatação " %f ". Os especificadores mais usados na prática, além de " %f " (para números reais), são " %i " (para valores inteiros), " %c " (para um caractere) e " %s " (para textos). Na exibição de valores em ponto flutuante é possível controlar a quantidade de casas decimais exibidas, usando " %. n f ", sendo n o número desejado de casas decimais^3. Cada especificador de formatação deve ter uma variável ou expressão correspondente na lista de argumentos. Exemplo:
printf("A área do círculo de raio %f vale %.2f",raio, A);
A existência da string de controle é obrigatória, mas a lista de argumentos não tem sentido na impressão de textos fixos. Para pular uma linha é preciso usar a seqüência de escape ' \n ', no ponto do texto em que deve ocorrer o salto. Por exemplo, a instrução
printf("Linha 1 \n Linha 2\n\nLinha3");
produzirá o seguinte resultado:
Linha 1 Linha 2
Linha 3
2.3.2 Leitura de dados usando a função scanf
A função de leitura geral scanf , definida no arquivo de cabeçalho stdio.h , lê e formata informações do dispositivo de entrada padrão do computador. De forma semelhante à função printf , a função scanf utiliza uma string de controle e especificadores de formatação para indicar como o valor de entrada será tratado (ver Apêndice 3).
Por exemplo, a instrução a seguir lê um valor digitado no teclado, formata-o como um valor em ponto flutuante e o armazena na variável raio.
(^2) Arquivos de cabeçalho são discutidos nos capítulos 3 e 5. (^3) O Apêndice 1 mostra exemplos de uso da função printf com outros especificadores de formatação.
String de controle
Lista de argumentos
Especificador de formatação
ECA301 – Computação I (2006) 2 – Expressões, entrada e saída de dados
Neste caso, o resultado correto pode ser obtido se um dos operandos for entendido como um valor de ponto flutuante por meio de uma conversão temporária para float. Exemplo:
float x; /* Declaração de variável float */
x = 5/2; /* INCORRETO: x recebe 2.0 */ x = ( float )5/2; /* CORRETO: x recebe 2.5 */
Outras opções que fornecem o resultado correto:
x = 5/( float )2; x = 5.0/2; x = 5/2.0; x = 5.0/2.0;
2.4.1 Atividade
Elabore um programa em linguagem C para calcular a força exercida pela coluna de um líquido sobre a área da válvula de um reservatório. Considere como dados de entrada do problema a altura h (m) do reservatório, o diâmetro d (m) da válvula e o peso específico γ do líquido (N/m 3 ). O resultado final deve ser o valor da força exercida (em Newtons) calculada como:
F
⋅ ⋅ d^2 ⋅ h ←
Solução
/* FORCA.C - Última modificação em 13/02/2006 / / Objetivo: Ilustrar a programação básica em C */
/* Diretivas de compilação */ #include <stdio.h> #define PI 3. main() { float h,d,gama,F; /* Declaração de variáveis */
printf("Cálculo de força\n"); printf("Altura do reservatório: "); scanf("%f",&h);
printf("Diâmetro da válvula: "); scanf("%f",&d);
printf("Peso específico do líquido: "); scanf("%f",&gama);
F = (PIgamaddh)/4;
printf("Valor da força exercida = %f",F); }
ECA301 – Computação I (2006) 2 – Expressões, entrada e saída de dados
2.5 Operadores
Toda expressão válida em linguagem C possui um valor numérico. Por exemplo, a expressão A = (12/2)3 – (3+5)/2* resulta igual a 14. Este valor é calculado de acordo com as regras de precedência da linguagem, ilustradas na tabela 2.2, em que os operadores de maior prioridade aparecem no topo da tabela^4.
Operadores ( ) [ ]. (operador ponto) -> (operador seta) Funções
- & (unários) sizeof ( cast) ++ --
- / % (aritméticos)
- – < <= > >= == != ! (negação lógica) && (operação lógica E) || (operação lógica OU) ?: (operador condicional ternário) = += -= *= /= %= (atribuições)
- / % (aritméticos)
- & (unários) sizeof ( cast) ++ --
Tabela 2.2: precedência dos operadores
Em uma expressão, todas as ocorrências de operadores unários e do operador condicional ternário ( ?: ) são avaliadas da direita para a esquerda. Os demais operadores são avaliados da esquerda para a direita.
2.5.1 Operadores aritméticos
A tabela 2.3 mostra os operadores aritméticos válidos em C.
Operador Ação
- Adição
- Subtração ou operador menos unário
- Multiplicação / Divisão (inteira ou real) % Módulo (resto da divisão inteira) ++ Incremento unitário -- Decremento unitário
Tabela 2.3: operadores aritméticos
(^4) Alguns dos operadores mostrados na tabela serão discutidos nos próximos capítulos. Existem outros
operadores válidos em linguagem C que não estão relacionados na tabela 2.2!