Introdução a Programação C

Recife, 2009

Programação I

Sônia Virginia Alves França

Volume 1

Universidade Federal Rural de Pernambuco

Reitor: Prof. Valmar Corrêa de AndradeVice-Reitor: Prof. Reginaldo BarrosPró-Reitor de Administração: Prof. Francisco Fernando Ramos CarvalhoPró-Reitor de Extensão: Prof. Paulo Donizeti SiepierskiPró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José FreirePró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo FerreiraPró-Reitora de Ensino de Graduação: Profª. Maria José de SenaCoordenação Geral de Ensino a Distância: Profª Marizete Silva Santos

Produção Gráfica e EditorialCapa e Editoração: Allyson Vila Nova, Rafael Lira e Italo AmorimRevisão Ortográfica: Marcelo MeloIlustrações: Diego AlmeidaCoordenação de Produção: Marizete Silva Santos

Sumário

Apresentação ........................................................................................5

Conhecendo o Volume 1 ......................................................................6

Capítulo 1 – Introdução ao C ...............................................................9

1.1. Programas e Programação de Computadores ............................9

1.2. Linguagens de Programação .....................................................11

1.3. Breve Histórico da Linguagem de Programação C ...................14

1.4. Criação, Compilação e Execução de um Programa ..................15

Capítulo 2 – Conceitos Preliminares para Programar em C ...........20

2.1. Estrutura de um Programa Básico em C ...................................21

2.2. Palavras Reservadas do C ........................................................24

2.3. Uso de Comentários ..................................................................25

2.4. Os Fundamentos do Ambiente C ...............................................27

2.5. Conhecendo o Dev-cpp .............................................................30

Capítulo 3 – Tipos de Dados, Variáveis e Constantes .....................36

3.1. Tipos de dados ..........................................................................36

3.2. Variáveis e Constantes ..............................................................38

3.3. Operador de Atribuição (=) ........................................................45

Capítulo 4 – Comandos de Entrada e Saída de Dados ....................50

4.1. Entrada de Dados ......................................................................50

4.2. Saída de Dados .........................................................................55

4.3. Erros Frequentes no Uso dos Comandos de Entrada e Saída .61

4.4. Primeiros programas em C ........................................................62

Capítulo 5 – Operadores, Expressões e Funções Matemáticas .....71

5.1. Operadores Básicos ..................................................................71

5.2. Operadores Aritméticos de Atribuição ......................................83

5.3. Operadores ++ e -- ....................................................................83

5.4. Conversão de tipo ......................................................................84

5.5. Funções Matemáticas (biblioteca math.h) .................................86

Considerações Finais .........................................................................96

Conhecendo a Autora .........................................................................97

Apresentação

Caro(a) cursista,

Seja bem-vindo (a) ao primeiro módulo da disciplina Programação I. Nesta disciplina, você irá aprender a programar na linguagem de programação C, uma das mais utilizadas mundialmente. Desenvolver programas e garantir que estes sejam confiáveis, eficientes e agradáveis de usar requer conhecimento técnico e muito treinamento.

Este livro foi escrito pensando em você, que está iniciando neste mundo da programação de computadores e que precisa ser apresentado, com tranquilidade, a um conjunto de novos conceitos. Os assuntos serão transmitidos gradativamente, de forma que você os absorva com naturalidade.

Este livro contém muitos exemplos de questões resolvidas, comentadas em detalhes, para que você não encontre dificuldades para aprender cada assunto. Além de apresentar dicas para que você desenvolva seus programas de forma eficiente e não cometa os principais erros de programação que ocorrem com quem está iniciando a programar. Ao final de cada capítulo, você poderá testar o seu aprendizado e assimilar melhor o que foi estudado, através da resolução de exercícios. Isto é muito importante! Não deixe de resolvê-los.

De antemão, informamos que programar é muito bom, você vai gostar! Nada melhor do que ver um programa rodando e saber que foi você quem o criou. Mas, não desanime se encontrar alguma dificuldade durante esta caminhada. Às vezes ocorre um erro no programa e não sabemos onde está o problema. Seja persistente! Ao longo do tempo, a experiência vai te deixar mais seguro e você conseguirá encontrar tais erros com facilidade.

O objetivo deste primeiro módulo é fazer uma introdução à linguagem C, conhecer um pouco da sua história e iniciar o estudo da sintaxe da linguagem, que possibilitará o desenvolvimento de programas básicos. Ao final deste primeiro módulo, você já estará desenvolvendo seus primeiros programas em C. O que você está esperando? Vamos começar?

Bons estudos!

Professora Sônia Virginia Alves França

6

Programação I

Conhecendo o Volume 1

Neste primeiro volume, você irá encontrar o módulo 1 da disciplina: Programação I. Este volume está estruturado em cinco capítulos, que serão estudados ao longo de 15h/aula. Para facilitar seus estudos, veja a organização deste primeiro volume.

Capítulo 1: Introdução ao C

Carga Horária do Capítulo 1: 2 h/aula

Objetivos do Capítulo 1: Introduzir os conceitos básicos da área de programação e apresentar um breve histórico sobre a linguagem C.

Conteúdo Programático do Capítulo 1

» Conceito de programas e programação de computadores;

» Linguagens de programação;

» Breve histórico da linguagem de programação C;

» Etapas do desenvolvimento de um programa.

Capítulo 2: Conceitos Preliminares para Programar em C


Objetivos do Capítulo 2: Apresentar detalhes mais específicos da linguagem, necessários para dar início à programação em C. Neste capítulo, também será apresentado o ambiente de programação que utilizaremos no desenvolvimento dos programas.


» Estrutura de um programa básico C;

» Palavras reservadas do C;

» Uso de comentários;

» Fundamentos do ambiente C;

» Conhecendo o Dev-cpp.

7

Programação I

Capítulo 3: Tipos de Dados, Variáveis e Constantes


Objetivos do Capítulo 3: Apresentar os tipos de dados suportados pelo C e introduzir o conceito de variáveis e constantes


» Tipos de dados;

» Variáveis e constantes;

» Operador de atribuição;

Capítulo 4: Comandos de Entrada e Saída de Dados


Objetivos do Capítulo 4: Apresentar os comandos de entrada e saída de dados do C. Neste capítulo, você terá acumulado conhecimento suficiente para desenvolver os primeiros programas em C.


» Entrada de dados;

» Saída de dados;

» Desenvolvimento dos primeiros programas C.

Capítulo 5: Operadores, Expressões e Funções Matemáticas


Objetivos do Capítulo 5: Apresentar os operadores básicos (aritméticos, relacionais e lógicos), além de funções complementares para o desenvolvimento de programas que executem expressões mais complexas.


» Operadores aritméticos, lógicos e relacionais;

» Operadores aritméticos de atribuição;

» Operadores ++ e --;

8

Programação I

» Conversão de tipos;

» Funções matemáticas.

Ao final de cada capítulo você encontrará:

» A seção “Atividades e Orientações de Estudo”: que contém exercícios para a fixação do assunto estudado, além de indicação de fóruns de discussão.

» A seção “Conheça Mais”: que contém dicas de sites e livros que devem ser lidos para ampliar os seus conhecimentos.

» A seção “Vamos Revisar?”: que apresenta um resumo dos principais tópicos abordados no capítulo.

9

Programação I

Capítulo 1 – Introdução ao C

Vamos conversar sobre o assunto?

Neste primeiro capítulo, será feita uma apresentação do que é programação e quais as principais linguagens de programação do mercado, dando ênfase à linguagem C. Este capítulo é importante, porque conheceremos um pouco da história da linguagem de programação que iremos aprender nesta disciplina. Sempre que conhecemos uma pessoa nova, queremos saber alguns detalhes da sua vida, não é mesmo? Quantos anos ela tem, onde nasceu, quem são seus pais, etc. Neste capítulo, também serão introduzidos conceitos utilizados na área de programação, visando a nossa preparação para nos lançarmos nesse mundo intrigante da criação de programas computacionais. Então, prontos (as) para o desafio?

1.1. Programas e Programação de Computadores

Um programa de computador é um conjunto de instruções que descrevem uma tarefa que será executada por um computador. Um programa de computador também é conhecido como software, software aplicativo, software de sistema ou simplesmente programa. O termo software é mais utilizado quando é feita uma referência à parte não física do sistema computacional, juntamente com o termo hardware, que faz referência ao conjunto de componentes eletrônicos que constituem um computador.

Os programas que permitem ao usuário fazer uma ou mais tarefas específicas, como as planilhas eletrônicas, editores de texto e jogos são chamados de software aplicativo ou aplicação. Já os programas que dão suporte funcional aos computadores, como os sistemas operacionais e drivers de dispositivos, são chamados de software de sistema1.

O ato de desenvolver programas é chamado de programação de computadores. A programação é o processo de escrita, teste e manutenção de um programa (ASCENIO e CAMPOS, 2002). O desenvolvimento de programas baseado em metodologias ou processos formalizados é conhecido por engenharia de software.

Saiba Mais

1 Além dos software aplicativo e software de sistema, ainda é possivel utilizar a categoria software embutido ou embarcado, destinado a funcionar dentro de uma máquina que não é um computador. Normalmente, estes software têm um propósito muito específico, como, por exemplo: controlar a injeção eletrônica de um carro ou gerenciar o cozimento dos alimentos no forno de microondas. Mais recentemente, surgiu também o software como serviço, que é um software que roda diretamente na internet, não sendo necessário instalar nada no computador do usuário.

10

Programação I

Os programas são escritos em uma linguagem de programação. Assim como o Português, o Inglês e o Espanhol, as linguagens de programação têm as suas regras e devemos seguí-las para escrever nossos programas corretamente. Portanto, a programação de computadores é uma ciência e, por isso, devemos seguir uma metodologia para termos como resultado: programas seguros e eficientes.

Em uma disciplina anterior, vocês aprenderam a desenvolver algoritmos, que são uma sequência de passos para realizar uma tarefa ou resolver um problema. Utilizamos algoritmos no nosso cotidiano para realizar atividades corriqueiras, definindo a sequência de passos que deve ser executada para atingirmos um objetivo, como, por exemplo, os passos que executamos para tomar banho, calibrar um pneu ou fazer um bolo (Figura 1.1).

Figura 1.1: Exemplos de algoritmos

Para efetuarmos estas atividades, seguimos uma sequência lógica de passos. Se esses passos não tiverem uma lógica, podemos não conseguir atingir o nosso objetivo. Se vocês observarem, para fazer um bolo, existe uma ordem em que os ingredientes devem ser adicionados à receita, caso não sigamos esta ordem, o bolo não ficará bom. Na programação irá ocorrer a mesma coisa, devemos passar as instruções ao computador, utilizando uma linguagem de programação, seguindo uma lógica – a lógica computacional.

Na próxima seção vamos abordar as linguagens de programação, de uma forma mais abrangente, tratando os principais conceitos que envolvem este assunto. Vamos seguir em frente?

11

Programação I

1.2. Linguagens de Programação

É através das linguagens de programação que poderemos criar nossos programas. Uma linguagem de programação é um conjunto de regras sintáticas e semânticas usadas para definir um programa. O conjunto de códigos (palavras e símbolos), compostos de acordo com essas regras, constituem o código fonte do nosso programa. Para ser executado pelo processador, o código fonte precisa ser traduzido para código de máquina.

Aprender uma linguagem de programação é um pouco similar a aprender um novo idioma. Temos que saber o significado das palavras, as regras da estruturação das frases, etc., para podermos nos comunicar corretamente no novo idioma.

Figura 1.2: Aprenda a dar ordens ao seu computador

Existem várias linguagens de programação. Vocês sabiam que cada linguagem de programação possui o seu conjunto de regras e um modo de funcionamento próprio? A escolha de uma linguagem de programação para o desenvolvimento de um programa deve estar atrelada ao tipo de problema que deseja resolver. Existem linguagens

Por que você não faz o que

eu quero?

12

Programação I

que são melhores para resolver um certo tipo de questão do que outras.

De acordo com Sebesta (2003), as linguagens de programação vêm sendo classificadas de várias formas: por geração, de acordo com o paradigma de programação, quanto ao grau de abstração, de acordo com a estrutura de tipos, dentre outras. Uma das classificações mais utilizadas é quanto ao grau de abstração. Segundo esta classificação, as linguagens de programação são divididas em três grupos: linguagens de máquina, linguagens de baixo nível e linguagens de alto nível.

A linguagem de máquina é a linguagem natural dos computadores. Estas linguagens são ininteligíveis para o ser humano não treinado. As linguagens de máquina são representadas por sequências de bits (zeros e uns). Estas sequências representam instruções que serão executadas pelo processador do computador. As instruções correspondem a sequências muito simples de operações, tais como: transferir um dado em memória para a CPU ou somar dois valores. As linguagens de máquina são dependentes do processador, isto é, uma determinada linguagem de máquina só poderá usada por um tipo de computador.

As linguagens de baixo nível são próximas da linguagem de máquina. No entanto, os zeros e uns que formam uma instrução foram substituídos por palavras que representam tais instruções, tornando-as um pouco mais legíveis. Estas linguagens são mais voltadas para a máquina, isto é, são escritas usando as instruções do microprocessador do computador. São chamadas de linguagens Assembly (que significa montagem). Estas linguagens apresentam as seguintes vantagens: os programas são executados com maior velocidade de processamento (já que são executadas diretamente pela máquina) e ocupam menos espaço na memória. No entanto, de modo geral, os programas em Assembly têm pouca portabilidade2 (um código gerado para um tipo de processador não serve para outro) e não são estruturados, tornando a programação mais difícil.

As linguagens de alto nível são mais próximas à linguagem humana (do Inglês, por exemplo) e mais distantes das linguagens de máquina. Por isso, são linguagens mais simples de entender, já que, em geral, utilizam uma sintaxe estruturada, tornando seu código mais legível. Necessitam de compiladores ou interpretadores para gerar instruções do microprocessador. Interpretadores fazem

Saiba Mais

2 No contexto da informática, a portabilidade de um programa é a sua capacidade de ser compilado ou executado em diferentes arquiteturas (seja de hardware ou de software).

Esse termo também vem sendo utilizado pelas empresas de telefonia móvel, quando se referem à portabilidade de número, ou seja, você muda de operadora, mas não muda o número do celular.

13

Programação I

a interpretação de cada instrução do programa fonte executando-a dentro de um ambiente de programação, Basic e Java são exemplos de linguagens interpretadas. Os compiladores fazem a tradução de todas as instruções do programa fonte gerando um programa executável. Estes programas executáveis (*.exe) podem ser executados fora dos ambientes de programação. A linguagem C e Pascal são exemplos de linguagens compiladas.

As linguagens de alto nível ainda podem ser divididas de acordo com a sua aplicação: genéricas (como C, Java e Pascal, que servem para o desenvolvimento de programas de propósito geral) ou específicas (como Fortran - utilizada para execução de cálculos matemáticos, LISP - desenvolvimento de aplicações na área de inteligência artificial e CLIPPER – utilizada para aplicações que manipulam bancos de dados). As vantagens das linguagens de alto nível são: portabilidade (por serem compiladas ou interpretadas podem ser executadas em várias plataformas com pouquíssimas modificações) e facilidade de desenvolvimento de programas. No entanto, as rotinas geradas são mais genéricas (e mais complexas) e por isso são mais lentas e ocupam mais memória.

A figura 1.3, a seguir, apresenta um trecho de código escrito em linguagem de máquina, linguagem de baixo nível e linguagem de alto nível, respectivamente.

Linguagem de Máquina

10110101 11100110 11000100

Linguagem de Baixo Nível

LOAD BASE ADD BONUS

STORE SALARIO

Linguagem de Alto Nível

Salario = Base + Bonus

Figura 1.3: Trecho de código em diferentes linguagens

Notem como o código em linguagem de máquina é incompreensível. Difícil entender essas sequências de zeros e uns, não é mesmo? O código na linguagem de baixo nível é mais legível e passamos a entender as instruções. Na linguagem de alto nível, o código fica menor e muito mais simples. Em qual tipo de linguagem vocês querem programar? Nem precisamos parar para pensar, não é mesmo?

14

Programação I

Figura 1.4: Linguagens de baixo nível x linguagens de alto nível

1.3. Breve Histórico da Linguagem de Programação C

Vamos conhecer um pouco sobre a história do C? A linguagem de programação C nasceu em 1972 nos laboratórios Bell, Estados Unidos. Seus criadores são Brian Kernighan e Dennis M. Ritchie. A linguagem C foi criada a partir da linguagem B (sugestivo, não é?), que havia sido desenvolvida no final dos anos 60 por Ken Thompson.

O C é uma linguagem de alto nível, compilada e estruturada3. No entanto, o C possui instruções de baixo nível, bem próximas à linguagem de máquina, que só o Assembler possui. O objetivo dos seus criadores era usar o C para desenvolver o sistema operacional UNIX, que originalmente foi escrito em Assembly (linguagem de baixo nível). Desde então, espalhou-se por muitos outros sistemas e tornou-se uma das linguagens de programação mais usadas, e influenciando o desenvolvimento de muitas outras linguagens como C++ e Java.

Com a linguagem C podemos construir programas organizados e concisos (características dos programas das linguagens de alto

Saiba Mais

3Uma linguagem é considerada estruturada quando permite que o programador pegue trechos de maior uso do seu programa e transforme-os em pequenos módulos (procedimentos e funções) que serão reutilizados sempre que necessário.

15

Programação I

nível), ocupando pouco espaço de memória e com alta velocidade de execução (como o Assembler). Infelizmente, dada toda a flexibilidade da linguagem, também poderemos escrever programas desorganizados e difíceis de serem compreendidos. Portanto, cabe ao programador de C utilizar boas práticas de programação, para ter programas legíveis e de fácil manutenção.

Existem inúmeras razões para que o C seja uma das linguagens mais preferidas dos programadores. As características da linguagem C mostram o porquê de sua ampla aceitação. Vejamos algumas características da linguagem C.

» Portabilidade entre máquinas e sistemas operacionais;

» Dados compostos em forma estruturada;

» Programas estruturados;

» Total interação com o sistema operacional;

» Código compacto e rápido, quando comparado ao código de outras linguagens de alto nível.

Agora que já conhecemos um pouco mais da linguagem C, vamos entender o processo de desenvolvimento de um programa. Quais são os passos que devemos seguir para termos um programa pronto? Vamos começar a falar sobre isto agora mesmo. Continuem firmes na leitura!

1.4. Criação, Compilação e Execução de um Programa

Nesta seção, vamos estudar as etapas de desenvolvimento de um programa em C. O desenvolvimento de um programa é dividido em três etapas, como mostra a figura 1.5.

Figura 1.5: Estados do desenvolvimento de um programa em C

A primeira etapa para o desenvolvimento de um programa em C é

16

Programação I

a criação do programa fonte, que consiste no “texto” formado pelo conjunto de comandos que nós desejamos que o computador execute. O programa fonte deve ser escrito respeitando as regras da linguagem. De modo geral, os programas fontes são digitados em editores de texto genéricos ou específicos dos ambientes de programação. No próximo capítulo deste volume, vamos conhecer detalhadamente o ambiente de programação que será utilizado para o desenvolvimento dos nossos programas em C.

Com o programa fonte pronto, passamos para a etapa de compilação. O compilador é um programa que verifica se o programa fonte não apresenta nenhum erro de sintaxe e gera o programa executável. Quando o programa fonte apresenta algum problema, dizemos que ocorreu um “erro de compilação”. Assim, o programador deverá avaliar o programa fonte, para a retirada de tais erros. Normalmente, os compiladores indicam os prováveis erros de sintaxe cometidos pelo programador. Se o programa não tiver erros de sintaxe, o compilador irá gerar o programa executável.

A etapa final consiste na execução do programa executável. Neste momento, o programador deverá testar se o programa está produzindo os resultados esperados. Quando o programa apresenta algum erro nesta fase, como, por exemplo, mostrar um resultado incorreto, dizemos que ocorreu um “erro de lógica” ou “erro de execução”. Isso ocorre porque, apesar do programa não ter apresentado erros de sintaxe, o que tornou possível a geração do programa executável, a sequência de comandos não foi definida de forma correta. Quando ocorre um erro de lógica, o programador deverá revisar o seu programa fonte e passá-lo novamente pela fase de compilação, para que um novo executável, sem erros, seja gerado. Como o compilador não nos avisa onde estão os erros de lógica, estes são mais difíceis de serem corrigidos.

Após ter certeza que o programa executável está correto, sem erros de lógica, o programador poderá entregá-lo ao seu cliente. É importante fazermos vários testes nos nossos programas. Testar com vários valores e verificar se está realmente tudo como esperado. Não fica bem nosso cliente ficar ligando, dizendo que o programa está com BUG!4 Lembrem-se sempre, o computador só executa as instruções que nós mandarmos. Se houver erros, a responsabilidade será nossa que não fizemos o programa corretamente! Vocês não vão querer passar por uma situação como essa? Vão?

Saiba Mais

4 Bug é um erro no funcionamento de um programa. É também chamado de erro de lógica, e pode causar discrepâncias no objetivo ou impossibilidade de utilização de um programa de computador. O uso do termo bug para descrever defeitos inexplicáveis foi parte do jargão da engenharia por várias décadas. Acredita-se que o termo foi criado por Thomas Edison quando um inseto (bug, em Inglês) causou problemas de leitura em seu fonógrafo em 1878.

17

Programação I

Nesta fase de execução do programa executável, nós também devemos verificar a usabilidade do programa, ou seja, se o programa ficou fácil de ser utilizado pelo seu usuário. Quando o programa é de difícil utilização ou confunde o usuário, induzindo-o ao erro, ele perde o interesse em utilizá-lo ou comprá-lo. Também devemos verificar se nosso programa tem um bom desempenho, ou seja, se ele processa rapidamente as operações. Usuário não gosta de programa lento, não é mesmo?

Atividades e Orientações de Estudo

Agora é o momento de analisarmos se os assuntos abordados neste capítulo foram bem absorvidos. Foram vistos muitos conceitos novos, não é mesmo? Vamos responder as questões a seguir. Caso sintam necessidade, releiam alguma seção que não foi muito bem assimilada ou complementem as respostas com a leitura dos sites indicados na próxima seção. Vocês estão preparados(as)?

1. Para que serve uma linguagem de programação?

2. Quais as desvantagens das linguagens de baixo nível?

3. Por que desejamos programas portáveis?

4. O que motivou a criação da linguagem C?

5. A linguagem C é de baixo ou alto nível?

6. A linguagem C é compilada ou interpretada?

7. Por que os erros de lógica são mais difíceis de serem corrigidos?

8. Por que devemos nos preocupar com a usabilidade dos nossos programas?

Conheça Mais

Para ampliar os seus conhecimentos sobre os assuntos tratados neste capítulo, visite o site da OReilly. Neste endereço,

18

Programação I

http://oreilly.com/pub/a/oreilly/news/languageposter_0504.html, foi disponibilizado um pôster, muitíssimo interessante, como uma “árvore genealógica” das principais linguagens de programação dos últimos 50 anos. Vale a pena dar uma olhada.

É muito importante que vocês se cadastrem em algum fórum de discussão sobre a linguagem C. Assim, vocês poderão conversar e trocar ideias com programadores de C mais experientes. Exemplos de fóruns de C: DevMedia e Linha de código.

Vamos revisar?

Vamos dar uma reforçada em nosso aprendizado com esta pequena revisão dos principais conceitos apresentados neste capítulo. Observem o resumo a seguir:

» Programa: é um conjunto de instruções que descrevem uma tarefa que será executada por um computador.

» Programação de computadores: é o processo de escrita, teste e manutenção de um programa.

» Algoritmo: sequência de passos para realizar uma tarefa ou resolver um problema.

» Linguagem de programação: é um conjunto de regras sintáticas e semânticas usadas para definir um programa.

» Linguagem de máquina: é a linguagem natural dos computadores. As instruções são formadas por zeros e uns. Estas linguagens não são legíveis para um programador sem experiência.

» Linguagens de baixo nível: são linguagens escritas usando as instruções do microprocessador do computador. Estas linguagens são mais difíceis de entender e criar programas.

» Linguagens de alto nível: são linguagens mais próximas à linguagem humana e mais distantes das linguagens de máquina. São linguagens mais simples de entender, já que, em geral, utilizam uma sintaxe estruturada, tornando seu código mais legível.

» Compiladores: são programas que fazem a tradução de todas as instruções do programa fonte gerando um programa executável.

19

Programação I

» Interpretadores: são programas que interpretam cada instrução do programa fonte executando-a dentro de um ambiente de programação.

» Compilação: é o processo, executado pelo compilador, que verifica se existem erros de sintaxe no código fonte e gera um programa executável.

» Erro de sintaxe: ocorre durante o processo de compilação do programa, quando o programador, ao editar o seu programa fonte, não respeita alguma regra de sintaxe da linguagem de programação.

» Erro de lógica: ocorre durante a execução de um programa, devido um erro na lógica dos comandos.

20

Programação I

Capítulo 2 – Conceitos Preliminares para Programar em C


Neste capítulo, serão abordados conceitos preliminares que irão nos preparar para programar em C. Estes conceitos estão relacionados à estrutura de um programa básico em C. Aqui, também, será apresentado o ambiente de programação que utilizaremos para o desenvolvimento dos nossos programas – o Dev-cpp. Este ambiente apresenta uma interface amigável, que facilitará o processo de programação. Vocês devem baixar e instalar o Dev-Cpp5, o quanto antes, no computador que será utilizado para a prática desta linguagem.

É importante que vocês tenham paciência neste início de aprendizado, já que precisamos, inicialmente, acumular o conhecimento necessário para a construção de um programa completo em C. Visando facilitar o aprendizado, em alguns momentos, será feito um paralelo entre a sintaxe do C e do Portugol do VisuAlg6 (linguagem utilizada para escrever algoritmos).

Saiba Mais

5 O Dev-cpp é uma ferramenta gratuita e pode ser baixada acessando o site: www.bloodshed.net/devcpp.html

Saiba Mais

6 Conheça mais o VisuAlg pesquisando no site: http://www.apoioinformatica.inf.br/visualg/linguagem.htm

21

Programação I

Figura 2.1: Qualidades de um programador: atenção, paciência e persistência

Vale lembrar que qualquer linguagem de programação é assimilada através da resolução de exercícios. É importantíssimo que a prática de programar faça parte da rotina de vocês. Assim, separem sempre um tempo para resolver as questões propostas neste material. Vocês vão perceber o quanto é bom ver um programa rodando! Que venha o C!

2.1. Estrutura de um Programa Básico em C

Nesta seção, vamos estudar a estrutura de um programa básico em C. Visando facilitar o entendimento e não sobrecarregar vocês com muitos detalhes, alguns elementos da estrutura do programa serão omitidos. Mas, no momento certo, abordaremos tais elementos, certo? Assim, a estrutura do programa que será apresentada nesta seção, é a estrutura mínima de um programa em C.

Nas linguagens de programação em geral, existe uma estrutura que indica a ordem em que deve ser disposto cada elemento do programa. Esta ordem deve ser respeitada para que nossos programas fiquem corretos. Como será a estrutura de um programa em C?

A estrutura básica de um programa C deve seguir a seguinte ordem:

1. Inclusão de bibliotecas (quando necessário);

2. Declaração das constantes (quando necessário);

3. Programa principal;

22

Programação I

» Declaração de variáveis (quando necessário);

» Sequência de comandos.

Para entendermos melhor a estrutura básica de um programa C, vamos analisar o programa de exemplo 2.1, abaixo. Este programa calcula o cubo de um número inteiro fornecido pelo usuário. Na sequência, temos este programa resolvido utilizando o portugol, que é do conhecimento de vocês. Assim, fica fácil compararmos a estrutura do programa em C, com a estrutura do algoritmo. Não se preocupem em entender cada comando do exemplo abaixo, estamos apenas começando a estudar a linguagem C, certo?

Exemplo 2.1: Programa C – Cálculo do cubo de um número

1

2

3

4

5

6

7

8

9

10

11

#include <stdio.h>

main()

{

int num,c;

printf(“Cubo de um numero\n\n”);

printf(“Digite o numero: “);

scanf(“%d”,&num);

c = num*num*num;

printf(“\nCubo de %d = %d”,num,c);

getche();

}

Segue abaixo o algoritmo, escrito no VisuAlg, que calcula o cubo de um número.

23

Programação I

Exemplo 2.2: Algoritmo – Calculo do cubo de um número

1

2

3

4

5

6

7

8

9

10

algoritmo “Cubo”

var

num, c: inteiro

inicio

escreval(“Cubo de um numero”)

escreva(“Digite o numero: “)

leia(num)

c <- num*num*num

escreval(“Cubo de “, num, “ = “, c)

fimalgoritmo

Um programa em C inicia com a inclusão de bibliotecas. Uma biblioteca é um arquivo que contém comandos complementares, que são utilizados pelo nosso programa. Para a inclusão de uma biblioteca devemos usar um comando que é chamado de diretiva de compilação. Este comando informa ao compilador quais bibliotecas devem ser anexadas ao programa executável. Assim, o comando para a inclusão de uma biblioteca tem a seguinte sintaxe:

Sintaxe

#include <nome_do_arquivo_da_ biblioteca>

De acordo com a sintaxe, para incluir uma biblioteca ao nosso programa devemos colocar a diretiva de compilação #include e, entre os símbolos < e >, colocamos o nome do arquivo da biblioteca. De maneira geral, os arquivos de biblioteca têm a terminação .h (esse h vem de header, ou seja, este é um arquivo de cabeçalho). Para cada biblioteca, que será incluída no nosso programa, devemos colocar um comando #include. No exemplo 2.1, na linha 1, é feita a inclusão de uma biblioteca: stdio.h. Na medida em que formos aprendendo os comandos, serão indicadas quais bibliotecas devem ser incluídas no programa. A quantidade de bibliotecas e quais bibliotecas serão

24

Programação I

incluídas dependem dos comandos que serão utilizados no programa. Pode ser que em um programa não seja necessário incluir nenhuma biblioteca.

O segundo item da estrutura de um programa C é a declaração das constantes, esse item é opcional, só constará no nosso programa, caso seja necessário. Veremos a declaração de constantes, em detalhes, no próximo capítulo. No exemplo 2.1 não foi necessário o uso de constantes.

O terceiro item da estrutura do programa C é o programa principal. É no programa principal que colocaremos a sequência de comandos que deve ser executada para a solução do problema que desejamos resolver. Nós devemos informar onde começa e termina o programa principal. O programa principal inicia com: main()7, como mostra a linha 2, do exemplo 2.1. A sequência de comandos do programa principal é delimitada por um par de chaves: { (abre chaves) e } (fecha chaves). As chaves que delimitam o corpo do programa principal8 aparecem nas linhas 3 e 11, do exemplo 2.1. Fazendo uma comparação com o algoritmo do exemplo 2.2, as chaves fazem o papel do “inicio” e “fimalgoritmo”, das linhas 4 e 10.

Logo no início do programa principal, devem ser declaradas as variáveis (que serão abordadas no próximo capítulo). A declaração de variáveis é um item opcional, pode acontecer de não precisarmos declarar variáveis no nosso programa. No exemplo 2.1, a declaração de variáveis é feita na linha 4. Foram declaradas duas variáveis do tipo inteiro: num e c. No algoritmo, exemplo 2.2, as variáveis são declaradas fora do programa principal, na seção de declaração de variáveis (linhas 2 e 3).

Após a declaração das variáveis, colocamos a sequência de comandos que o programa deverá executar. O programa termina com o fecha chaves que delimita o programa principal.

Agora que já sabemos como é a estrutura de um programa básico em C, vamos começar a aprender a sintaxe dos comandos para darmos início ao desenvolvimento dos nossos programas.

2.2. Palavras Reservadas do C

Como mencionado no capítulo anterior, as linguagens de programação são formadas por um conjunto de regras de sintaxe e

Saiba Mais

7 Do Inglês, main significa principal. Todo programa C começa a sua execução a partir do programa principal. Assim, o programa principal é uma parte obrigatória na estrutura de um programa C.

Saiba Mais

8 Chamamos de corpo do programa principal toda a sequência de comandos que faz parte do programa principal. Ou seja, a sequência de comando que aparece entre as chaves de abertura e término do programa principal.

25

Programação I

semântica que ditam como o programa deve ser escrito. Com isso, dentro dessas regras, existe um conjunto de palavras que tem um significado para a linguagem de programação – são as palavras reservadas. Uma palavra reservada é, essencialmente, um comando e, na maioria das vezes, as palavras reservadas de uma linguagem definem o que pode ser feito e como pode ser feito.

As palavras reservadas são de uso exclusivo da gramática da linguagem, por isso, não podem ser utilizadas, pelo programador, para dar nome a alguma variável, constante ou função do seu programa. Assim, um programador não pode ter uma variável chamada “int” no seu programa C, já que “int” é uma palavra reservada que indica um tipo de dado.

Na linguagem C temos 32 palavras reservadas. Todas as palavras reservadas do C são escritas em minúsculo. A tabela abaixo mostra as palavras reservadas, conforme definido pelo padrão ANSI9, para a linguagem C.

auto break case char const switch volatile

continue

default do

double else

typedef while enum extern

float for

goto union

if int

long register

unsigned return short

signed sizeof static struct void

No Dev-cpp, ambiente de programação que será utilizado, sempre que digitarmos uma palavra reservada no nosso programa, esta aparecerá em negrito. Isto facilita no momento da programação, pois não precisaremos decorar esta lista de palavras reservadas. Que alívio! Assim que uma palavra ficar em negrito no nosso programa, poderemos verificar se estamos utilizando-a de forma correta.

2.3. Uso de Comentários

Os comentários são utilizados para documentar um programa. A colocação de comentários em um programa é uma das boas práticas de programação10. Os comentários irão facilitar o entendimento e manutenção de programas. Por exemplo, um programador é responsável por desenvolver o sistema de controle de vendas

Saiba Mais

9 A sigla ANSI significa: American National Standards Institute (Instituto Nacional Americano de Padronização). É uma organização que tem por objetivo facilitar a padronização dos trabalhos de seus membros.

Saiba Mais

10 Ao desenvolver nossos programas utilizando boas práticas de programação, teremos como resultado um código fonte mais legível e um progama executável mais seguro e eficiente. Ao longo deste material serão ensinadas boas práticas de programação.

26

Programação I

da sua empresa. Como o sistema é grande, após um tempo, ele não lembrará mais o porquê de ter colocado uma sequência de comandos no seu programa. Se o programa estiver bem comentado, o programador poderá, rapidamente, ter esta resposta. Além disso, quando desenvolvemos programas em grupo, é importante que os demais membros do grupo entendam o raciocínio do nosso programa e isso pode ser explicado através dos comentários.

Os comentários podem ser colocados em qualquer parte do programa. Quando o compilador identifica um comentário, ele os ignora, já que os comentários são apenas informações para o programador. A linguagem C fornece dois tipos de comentários: de linha e de bloco. Vamos detalhar como funciona cada um deles.

Os comentários de linha são mais utilizados quando desejamos comentar uma única linha do nosso programa. Um comentário de linha possui a sintaxe a seguir:

Sintaxe

// texto do comentário

Um comentário de linha inicia com duas barras “//” e, na sequência, vem o texto do comentário. O exemplo 2.3, a seguir, apresenta um programa comentado. Na linha 7, temos o exemplo de um comentário de linha. Este comentário serviu para informar para que serve a variável C. Assim que o compilador encontra “//”, ele ignora todo texto que vem após as duas barras11. Este tipo de comentário age apenas na linha que ele é inserido.

O segundo tipo de comentário disponível na linguagem C é o comentário de bloco. Os comentários de bloco são utilizados quando queremos fazer um comentário maior, que compreenda mais de uma linha de comentário. A sintaxe do comentário de bloco é a seguinte:

Sintaxe

/* texto do comentário

texto do comentário

texto do comentário */

Um comentário de bloco inicia com barra-asterisco “/*” e termina por asterisco-barra “*/”. O compilador irá ignorar tudo o que encontrar

Saiba Mais

11No Dev-cpp, quando colocamos um comentário, as letras do texto comentado ficam cinza.

27

Programação I

entre estes dois símbolos. Veja no exemplo 2.3, que nas linhas 2, 3, e 4 aparece um comentário de bloco. Este tipo de comentário do exemplo é utilizado para identificar quem é o programador quando o programa foi feito e o que o programa faz. Devemos adotar este tipo de comentário no início dos nossos programas. Assim, ao abrir um programa, rapidamente, saberemos para que ele serve. Devemos tomar cuidado para não esquecer o “*/” que fecha o comentário de bloco.

Exemplo 2.3: Programa C Comentado – Cálculo do cubo de um número

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#include <stdio.h>

/* Programador: Sônia França

Data: 09/03/2009

Programa calcular o cubo de um número */

main()

{

int Num, C; // C guarda o cubo do numero

printf(“Cubo de um numero\n\n”);

printf(“Digite o numero: “);

scanf(“%d”,&Num);

C = Num*Num*Num;

printf(“\nCubo de %d = %d”,Num,C);

getche();

}

2.4. Os Fundamentos do Ambiente C

Na seção 1.5, do capítulo anterior, foram abordados os processos de criação, compilação e execução de um programa. Nesta seção, vamos detalhar um pouco mais estes processos, entendendo os

28

Programação I

fundamentos do ambiente C. A figura 2.2 apresenta um ambiente C, com as seis fases pelas quais passa um programa, desde a sua edição, até a sua execução.

Figura 2.2: Ambiente C

A fase 1 compreende a edição do nosso programa. O programa é criado com a utilização de um editor e é armazenado no disco do computador (HD - Hard Disk). O arquivo que contém o nosso programa tem a terminação .c, e este é chamado de programa fonte ou código fonte.

Ao terminar a edição do programa, o programador solicita que o seu código fonte seja compilado. O compilador traduz o código fonte para o código em linguagem de máquina (também chamado de código objeto). Vocês se lembram das diretivas de compilação? Antes da tradução, temos a fase 2, em que o pré-processador

29

Programação I

analisa o código fonte, executando as diretivas de compilação. O pré-processador também é responsável por eliminar os comentários que o programador colocou no seu código fonte. O pré-processador é ativado automaticamente pelo compilador. Na fase 3, é que ocorre o processo de compilação, após o código fonte ter sido pré-processado. Para que o processo de compilação seja concluído, o programa não pode apresentar erros de sintaxe.

Na fase 4, ocorre o processo de linking, que consiste na ligação do código objeto, gerado pelo compilador, com o código das funções que estão disponíveis nas bibliotecas que incluímos no nosso programa. Ou seja, no exemplo 2.1, em que foi incluída uma biblioteca, o linker deverá localizar o arquivo da biblioteca e fazer a ligação com o código objeto. Esta fase termina com a geração do programa executável, armazenando-o no disco do computador. No Dev-cpp, o programa executável é armazenado no mesmo diretório que estiver armazenado o código fonte. Na Figura 2.3, temos um diretório contendo o arquivo do código objeto (.c – C source file) e o programa executável (.exe – application). O arquivo do programa executável não pode ser editado, o que nós podemos editar é o arquivo do código fonte.

Figura 2.3: Diretório contendo código objeto e o programa executável

As fases 5 e 6 consistem na execução do programa executável. Para dar início a execução de um programa, é necessário que o mesmo esteja na memória principal do computador. Isto é feito na fase 5, pelo carregador do programa. O carregador pega o programa executável que está armazenado no disco e o transfere para memória principal. Assim que o programa está na memória principal do computador, ele está pronto para ser executado. A execução de um programa é feita pela CPU12, que executa as instruções do programa, uma após a outra, até o seu término.

Saiba Mais

12 CPU é a sigla para Central Processing Unit, em Inglês, ou Unidade Central de Processamento. A CPU é a parte do computador que processa as instruções contidas em um programa.

30

Programação I

Na próxima seção, vamos conhecer o Dev-Cpp, que possibilitará a criação, compilação e execução dos nossos programas. Com o Dev-cpp poderemos observar as fases aqui descritas.

2.5. Conhecendo o Dev-cpp

O Dev-Cpp é um ambiente de programação que edita, compila e executa programas C e C++13. Sabem porque iremos usar o Dev-cpp para desenvolver nossos programas? O Dev-cpp é gratuito (muito importante!) e possui uma interface bastante amigável (mais importante ainda!). A Figura 2.4 apresenta a tela principal do Dev-cpp.

Figura 2.4: Tela principal do Dev-cpp

Como mencionado no início deste capítulo, vocês deverão “baixar” o Dev-cpp e instalar no seu computador, para que possamos fazer os nossos programas. O processo de instalação não apresenta dificuldades. Vocês só devem ficar atentos no momento que for questionado sobre qual idioma deseja utilizar, para que faça a escolha do idioma correto (Português), certo? Assim, a interface do Dev-cpp ficará toda em Português, facilitando os seus estudos.

Vamos analisar a tela principal do Dev-cpp, apresentada na figura 2.4. Na parte 1 temos o menu principal do Dev-cpp, que disponibiliza

Saiba Mais

13 C++ é uma linguagem de programação que surgiu a partir do C.

31

Programação I

as seguintes opções:

» Arquivo: o menu arquivo disponibiliza, basicamente, as opções para criar, salvar, imprimir e fechar arquivos.

» Editar: neste menu encontraremos as opções: copiar, colar, selecionar, refazer e desfazer.

» Localizar: as opções deste menu nos possibilitam localizar alguma palavra no programa fonte, além de permitir substituições de uma palavra por outra.

» Exibir: neste menu temos as opções que nos permite exibir ou esconder itens da interface do ambiente, como por exemplo: barra de ferramenta e barra de status.

» Projeto: permite a adição ou remoção de arquivos em um projeto.

» Executar: é através deste menu que iremos chamar as opções para a compilação e execução do nosso programa.

» Debug: o debugador auxilia o programador a encontrar erros no programa, tornando possível acompanhar passo a passo a execução dos comandos do programa. Neste menu teremos as opções para utilização do debugador.

» Ferramentas: no menu ferramentas temos as opções para configurar o ambiente (mudar cores, tipo de letra, dentre outros) e também a opção para atualização do Dev-cpp.

» CVS14: este menu é utilizado por quem faz o controle de versões dos programas. Apesar de ser uma função bastante interessante, é mais utilizado quando trabalhamos em grupo ou com programas grandes.

» Janela: neste menu estão disponíveis as opções que nos permitem escolher qual janela de edição deve ficar visível no momento. Utilizamos esta opção quando temos vários programas abertos ao mesmo tempo.

» Ajuda: neste menu encontramos o help do Dev-cpp.

Na parte 2, da Figura 2.4, temos os ícones de atalhos para as opções mais utilizadas no Dev-Cpp. Se vocês deixarem o mouse sobre o ícone, aparecerá um texto, que informa o que ele faz. Na parte 3 temos a área de edição do programa. Para a área de edição ficar

Saiba Mais

14O CVS, ou Concurrent Version System (Sistema de Versões Concorrentes) é um sistema de controle de versões que permite que se trabalhe com diversas versões do mesmo arquivo. Este sistema mantém as versões antigas do seu arquivo e os logs de quem e quando manipulou os arquivos.

É especialmente útil para se controlar versões de um software durante seu desenvolvimento, ou para composição colaborativa de um documento.

32

Programação I

disponível, vocês deverão escolher a opção Arquivo/Novo/Arquivo Fonte. É nesta área que digitaremos os nosso programas (código fonte). A parte 4 fica visível quando nosso programa apresenta algum erro de compilação. O compilador indicará em qual linha foi encontrado um erro, e fornece uma dica do que pode ser o erro. Mesmo que vocês tenham instalado o Dev-cpp em Português, as mensagens de erro são apresentadas em Inglês. Por isso, é importante que vocês comecem a se familiarizar com estas mensagens, para que consigam tirar mais rapidamente os erros dos programas.

Segue abaixo um roteiro do que vocês precisam fazer para editar, compilar e executar seus programas no Dev-cpp:

1. Crie um arquivo fonte novo na opção: Arquivo/Novo/Arquivo Fonte;

2. Digite o programa fonte na área de edição. Ao terminar de editá-lo, salve o arquivo;

3. Compile o programa na opção: Executar/Compilar;

4. Se der algum erro no programa, vejam as indicações de erro fornecidas pelo compilador15. Conserte os erros, salve o arquivo e compile novamente. Isto deve ser feito até que seja apresentada uma mensagem indicando que o programa não tem erros de compilação.

5. Se vocês acessarem o diretório que o arquivo do código fonte foi armazenado, notarão que foi criado um arquivo com a extensão .exe (com o mesmo nome do arquivo do código fonte). Este é programa executável. Para executá-lo, escolha a opção Executar/Executar no Dev-cpp. Imediatamente, aparecerá a janela de execução do programa, como mostra a Figura 2.5.

Figura 2.5: Janela do programa em execução

É nesta janela que o programa será executado. Aqui o usuário

Saiba Mais

15 O erro de compilação pode não estar na linha que o complilador está indicando. O erro poderá estar: na linha que ele está indicando, na linha imediatamente acima, ou ainda, em linhas mais acima (menos comum de acontecer).

33

Programação I

deverá fornecer os dados solicitados pelo programa, neste caso o programa está solicitando que seja digitado um número. Além disso, também receberá os resultados fornecidos pelo programa. Quando a execução de um programa é finalizada, esta janela será fechada automaticamente.

Agora que já conhecemos o ambiente de desenvolvimento de programa C, precisamos aprender os comandos para fazer um programa completo. Nos próximos capítulos iremos ver tais comandos, para podermos começar a programar. Não fiquem ansiosos(as), a nossa hora de programar está chegando!


Vamos resolver mais uma lista de exercícios? Note que estamos conhecendo, aos poucos, os detalhes que envolvem a programação de computadores. A resolução das atividades propostas fará com que estes conceitos sejam assimilados de forma mais natural. É sempre importante complementar o nosso conhecimento com a leitura de livros e materiais disponíveis na Internet, indicados na seção “Conheça Mais”. Será que vocês estão lembrados (as) das respostas para as questões abaixo?

1. Quando é que precisamos incluir uma biblioteca em um programa C?

2. O que é diretiva de compilação?

3. O que deve ter no corpo do programa principal?

4. O que é uma palavra reservada?

5. Por que devemos comentar nossos programas?

6. Qual a função do pré-processador no momento da compilação de um programa?

7. Qual o papel do linker no processo de compilação?

8. Qual elemento do computador é responsável pela execução do programa?

34

Programação I

Conheça Mais

Vocês poderão aprender mais sobre boas práticas de programação nos sites:

http://www.ibm.com/developerworks/aix/library/au-hook_duttaC.html

http://www2.eletronica.org/artigos/eletronica-digital/programando-em-c-boas-praticas

Para conhecer mais detalhes do ambiente de programação que iremos utilizar, acessem os sites:

http://www.bloodshed.net/dev/index.html

http://www.uniqueness-template.com/devcpp/

Vamos revisar?

Nesta seção iremos revisar os principais tópicos vistos neste capítulo. Vale a pena dar uma lida para verificar como está o nosso aprendizado. Observem o resumo a seguir:

» A estrutura básica de um programa C deve seguir a seguinte ordem: inclusão de bibliotecas, declaração das constantes e programa principal. No corpo de programa principal temos: declaração de variáveis e sequência de comandos.

» Uma biblioteca é um arquivo que contém comandos complementares, que são utilizados pelo programa. Para a inclusão de uma biblioteca devemos usar um comando que é chamado de diretiva de compilação.

» As palavras reservadas de uma linguagem definem o que pode ser feito e como pode ser feito. O programador não pode utilizar uma palavra reservada da linguagem para dar nome as suas variáveis, constantes e funções.

» O uso de comentário nos programas é uma boa prática de programação, e facilita o entendimento do código fonte.

35

Programação I

» Passos para o desenvolvimento de um programa: edição, pré-processamento, compilação, ligação (linking), carregamento e execução.

» O compilador traduz o código fonte para o código em linguagem de máquina. O pré-processador analisa o código fonte, executando as diretivas de compilação.

» O linker faz a ligação do código objeto, gerado pelo compilador, com o código das funções que estão disponíveis nas bibliotecas que incluímos no programa.

» Ao ser executado, um programa deve ser carregado na memória. O carregador, também conhecido por loader, e responsável por acessar o programa armazenado no disco e carregá-lo para a memória principal do computador.

» Os programas são executados passo a passo pelo processador do computador.

36

Programação I

Capítulo 3 – Tipos de Dados, Variáveis e Constantes


Programas são feitos para manipular dados. Armazenar notas, calcular médias, alterar um endereço, etc. Os dados são a essência de um programa. Dados precisam ser armazenados e modificados ao longo da execução do programa. Neste capítulo, iremos conhecer os tipos de dados suportados pela linguagem C e aprender a definir constantes e variáveis.

Inicialmente, os comandos serão apresentados em separado. Mas, logo em seguida, veremos o ponto em que cada comando deve ser colocado na estrutura do programa, certo? Tenham paciência! Vocês irão notar que muito dos conceitos estudados nos capítulos anteriores serão referenciados neste capítulo. Mas isto não é problema, não é mesmo? Vamos continuar os nossos estudos, conhecendo mais um pouco da linguagem C.

3.1. Tipos de dados

Nesta seção, vamos aprender um conceito importante em programação, que é: tipo de dados. De maneira geral, os programas manipulam dados, armazenando-os e, muitas vezes, modificando seus valores. Primeiramente, vamos conhecer quais os tipos de dados são manipulados na linguagem C. Basicamente, a linguagem C, manipula quatro tipos de dados: inteiro, real, caractere e void16. Para cada tipo de dado, é necessária uma quantidade de bits17 para armazená-lo. Além disso, cada tipo de dado possui um conjunto de operações que pode ser executada sobre ele. Nas subseções seguintes, vamos detalhar cada tipo de dado separadamente.

3.1.1. Inteiro

Os dados do tipo inteiro são toda e qualquer informação numérica que pertença ao conjunto dos números inteiros relativos (negativo, nulo ou positivo). Os números inteiros, em C, se dividem em três tipos, como mostra a tabela a seguir.

Saiba Mais

16A linguagem C não possui o tipo lógico, que armazena verdadeiro ou falso.

Saiba Mais

17Bit é uma abreviatura de “Binary Digit” (dígito binário). Este termo foi criado pelo engenheiro belga Claude Shannon que em 1949 para simbolizar uma unidade de informação. Tudo na informática é medido em bits, desde o tamanho de um número até a velocidade de transferência de dados em uma rede. Por ser uma unidade binária, pode ter apenas dois valores, zero ou um.

A partir do bit, surgiu o byte, que nada mais é do que um conjunto de 8 bits. Existem diversos múltiplos dos bytes: um kilobyte (KB), equivalente a 1.024 bytes; um megabyte (MB), equivalente a 1.024 KB; e um gigabyte, equivalente a 1.024 MB.

37

Programação I

Tipo Tamanho Intervalo Suportado

short 16 bits -32.768 a +32.767

int 32 bits -2.147.483.648 a + 2.147.483.647

long

64 bits

-9.223.372.036.854.775.808 a

+9.223.372.036.854.775.807

Qual a diferença entre cada um deles? A diferença entre os tipos short, int e long é a quantidade de memória18 que é reservada para armazená-los. Veja como é simples: à medida que se utiliza mais memória, aumenta o intervalo do valor que pode ser armazenado. Por exemplo, para armazenar um dado do tipo short, são reservados 16 bits de memória. Com isso, o tipo short pode suportar um número inteiro no intervalo de -32.768 a +32.767, como apresentado na tabela. Portanto, dependendo do valor que será armazenado, deve ser escolhido um tipo (short, int ou long) que comporte tal valor. Por exemplo, para armazenar a idade de um funcionário, o tipo short é o mais adequado (já que a idade de uma pessoa é um valor que raramente ultrapassa 100). No entanto, para armazenar a quantidade de eleitores de uma cidade, deve-se usar o tipo int (note que em muitas cidades, a quantidade de eleitores ultrapassará o maior valor suportado pelo tipo short: 32.767). Para facilitar nosso estudo, neste material, sempre será usado o tipo int para armazenar os dados inteiros.

3.1.2. Real

Os dados do tipo real são toda e qualquer informação numérica que pertença ao conjunto de números reais (negativo, positivo ou nulo). Os números reais, em C, podem ser de dois tipos, como mostra a tabela abaixo:

Tipo Tamanho Intervalo Suportado

float 32 bits 3.4E-38 a 3.4E+38

double 64 bits 1.7E-308 a 1.7E+308

Para o tipo float são reservados 32 bits de memória, o que possibilita armazenar um valor no intervalo 3.4–38 a 3.438. Como o tipo float suporta valores bem altos, neste material, sempre será usado o tipo float para armazenar os dados reais.

Atenção

18A memória é a parte do computador que tem como função o armazenamento de dados. Quando um dado vai ser armazenado, precisamos reservar uma quantidade de memória para isto.

38

Programação I

3.1.3. Caractere

Na linguagem C, os caracteres são do tipo char, representados por toda e qualquer informação composta por um único caractere alfa numérico (a, b, c,...z, A, B, C,...Z, 0...9) ou especial (como por exemplo: ; # ? @ ! < ?). O tipo char armazena um único caractere. Quando se deseja armazenar vários caracteres, é necessário definir um vetor de caractere (mais detalhes na seção 3.2.2). Por exemplo, o nome de um aluno é formado por uma cadeia de caracteres, assim, será necessário usar um vetor de caracteres. Cada caractere armazenado ocupa o espaço de 8 bits de memória. Um caractere deve ser representado entre apóstrofo, por exemplo: ‘a’. Mas, quando temos uma cadeia de caracteres, esta deve ser representada entre aspas dupla, por exemplo: “Pedro Goncalves”.

3.1.4. Void

Em Inglês, void quer dizer vazio e é isto mesmo que o void é. Void é um tipo que não armazena nada (um tanto esquisito, não é?). Este tipo serve para indicar que um resultado não tem um tipo definido. Ele é utilizado quando estamos definindo funções nos nossos programas. Permite-nos desenvolver funções que não retornam nada e funções que não têm parâmetros. Voltaremos a falar do tipo void no Volume 2, no capítulo que aborda modularização.

3.2. Variáveis e Constantes

Agora que já sabemos os tipos de dados manipulados pela linguagem C, vamos aprender como reservar espaços de memória para o armazenamento dos nossos dados.

Qualquer dado que seja manipulado pelo programa deve ficar armazenado na memória principal do computador. Para que o armazenamento seja possível, precisaremos reservar espaços na memória principal do computador. As variáveis e constantes são unidades básicas de armazenamento dos dados em programação. Elas são um espaço de memória reservado para armazenar um certo tipo de dado e possuem um identificador (nome) para referenciar o seu conteúdo. Dessa forma, nossos dados ficam armazenados em constantes ou variáveis.

Uma variável pode conter, a cada instante, valores diferentes. No

39

Programação I

entanto, as constantes referem-se a valores fixos que não podem ser alterados durante a execução do programa. O modo como cada constante é representada depende do seu tipo (este assunto será detalhado um pouco mais a frente).

Para entender o conceito de variáveis e constantes, vamos fazer a seguinte analogia: um armário cheio de gavetas de tamanhos diferentes. Acompanhem o raciocínio: Pedro tem um armário e decide que em cada gaveta será guardado um tipo de roupa: camisa, bermuda, calça, etc.

Figura 3.1: Armário cheio de gavetas

Em uma dada gaveta, só podem ser armazenadas camisas. Não será permitido o armazenamento de calças nesta gaveta. Para facilitar a identificação, Pedro coloca uma etiqueta informando o que cada gaveta guarda. Com isso, Pedro poderá identificar, rapidamente, em qual a gaveta estão guardadas suas camisas.

Agora vamos associar a ideia das gavetas com a ideia de variáveis, constantes e tipo. As gavetas que guardam as roupas são como os espaços de memória que armazenam nossos dados. Assim como uma gaveta só pode armazenar um tipo de roupa, os espaços de memória são especificados para armazenar um tipo de dado. Dependendo do tipo de roupa, a gaveta precisa ser maior ou menor. Da mesma forma, dependendo do tipo de dado, é feito uma reserva de mais ou menos memória para armazená-lo (de acordo com as tabelas da seção 3.1).

As etiquetas das gavetas são os identificadores dos nossos

40

Programação I

espaços de memória. Assim, facilmente iremos encontrar um dado armazenado nos nossos espaços de memória. Quando temos uma variável, o conteúdo da nossa gaveta pode mudar ao longo do tempo. Mas, no caso de uma constante, seu conteúdo será sempre o mesmo.

Nas próximas seções, vamos aprender as regras para dar nomes às nossas variáveis e constantes e como criar as nossas gavetas – espaços de memória (variáveis e constantes).

3.2.1. Identificadores

Para que o compilador saiba quais dados estamos querendo manipular, eles precisam ter um nome. É como nós, todos temos um nome. Sabemos quando alguém está nos chamando quando falam o nosso nome. Vai acontecer a mesma coisa com os espaços de memória dos nossos programas, precisamos identificá-los de alguma forma. Os identificadores são os nomes que damos às nossas variáveis, constantes, funções e procedimentos usados no programa. Para criar um identificador é necessário respeitar as regras a seguir:

» O primeiro caractere deve ser uma letra ou _ (underscore);

» O restante do nome deve ser formado por caracteres pertencentes ao seguinte conjunto: a,b,c,..z, A,B,C,...Z, 0,1,2,...,9, _ (ou seja: letras, números e underscore);

» Não deve haver espaço em branco (ou seja, não existem identificadores compostos, formados por dois ou mais nomes);

» Não utilizar acentos, nem cedilha;

» Os identificadores podem ter até 32 caracteres;

» Não deve haver identificadores repetidos (Se dermos o mesmo nome para duas variáveis do nosso programa, o compilador não vai saber qual delas será chamada, e isso não pode acontecer).

A linguagem C faz distinção de maiúsculas e minúsculas. Assim, os identificadores: Media, MEDIA, MediA e media são diferentes. O fato de termos uma única letra de forma diferente (maiúscula ou minúscula), já faz com que os identificadores se diferenciem. Esta propriedade é chamada de case sensibility (sensibilidade a letras maiúsculas e minúsculas).

41

Programação I

DICA: Boa Prática de Programação

Escolham bem os nomes das variáveis e constantes do programa. Os identificadores escolhidos devem ser claros, a fim de explicitar o conteúdo que será armazenado, mas também não devem ser extensos para não dificultar a escrita.

A seguir, vamos verificar exemplos de identificadores corretos e incorretos:

» Identificadores corretos: a, x2, Nome_Aluno, Media, SalarioFuncionario. Note que, quando queremos usar identificadores com mais de uma palavra, que foi o caso de Nome_Aluno, usamos o _ para ligar uma palavra a outra. Ou usamos as palavras juntas, como o exemplo SalarioFuncionario. Lembrando que não podemos usar espaço em branco.

» Identificadores incorretos: 2m (começou com número), media* (caractere * não é permitido), Nome disciplina (não pode haver espaço em branco), funcionário (não pode acentuar).

Até este momento, vimos os conceitos de tipos de dados, variáveis, constantes e identificadores. Na próxima seção, estes conceitos serão utilizados em conjunto, para que possamos declarar as nossas variáveis, ou seja, criar espaços de memória para armazenar os dados manipulados pelo nosso programa. Continuemos a nossa leitura.

3.2.2. Declaração de Variáveis

Para que se possa usar uma variável em um programa, primeiramente, é necessário fazer a declaração dela. A declaração de uma variável informa ao processador duas coisas: o identificador (nome) da variável e o seu tipo de dado. As variáveis precisam de um nome para que o processador saiba onde desejamos armazenar o nosso dado. Além disso, toda variável precisa ser associada a um tipo de dado, para que o processador reserve o espaço de memória necessário para o seu armazenamento. Como visto na seção 3.1, cada tipo de variável, ocupa uma quantidade de bits diferente. Resumindo, toda variável possui um nome, um tipo e um conteúdo (ou valor que é armazenado na variável).

42

Programação I

A declaração de variáveis deve obedecer a seguinte sintaxe:

Sintaxe

tipo [variavel_1, variavel_2, ...];

Onde tipo é o tipo de dado (int, float, char) e variavel_1 é o nome da variável a ser declarada. O nome da variável deve seguir a regra dos identificadores (mencionadas na seção 3.2.1). Se houver mais de uma variável do mesmo tipo, seus nomes são separados por vírgulas. Notem que, no final do comando, aparece um ponto e virgula (;), indicando ao compilador que o comando terminou.

Exemplo 3.1: Declaração de Variáveis

1

2

3

int idade, matricula;

float media, total;

char letra, nome_aluno[20];

As variáveis idade e matricula são espaços de memória que armazenam números inteiros. As variáveis media e total armazenam números reais. Note que na linha 3, temos as variáveis letra e nome_aluno. Quando uma variável caractere tem apenas um único caractere, na sua declaração, é necessário apenas dar um nome a esta variável.

Quando houver necessidade de armazenar vários caracteres, temos o que é chamado de cadeia de caracteres, vetor de caracteres ou string. Uma cadeia de caracteres forma uma palavra ou frases. Para declarar uma variável capaz de armazenar uma cadeia de caracteres, devemos colocar ao lado do nome da variável, entre colchetes, um valor inteiro, que significa quantos caracteres podem ser armazenados nesta cadeia. Assim, a variável nome_aluno, declarada na linha 3, tem capacidade de armazenar uma palavra/frase com até 20 caracteres.

A figura 3.2 representa a memória do computador, após a declaração das variáveis do exemplo. Cada caixa representa uma variável. E, cada variável possui o seu identificador. Assim, esta declaração de variáveis resultou na reserva de seis espaços na memória. Toda vez que precisarmos acessar ou armazenar o conteúdo de uma variável, utilizaremos o seu identificador.

43

Programação I

Figura 3.2: Representação da memória do computador após a declaração de um conjunto de variáveis

Atenção

Como dito anteriormente, o C difere as letras minúsculas das maiúsculas. Assim, os tipos de dados e comandos que iremos aprender ao longo da disciplina, DEVEM ser escritos em minúsculo. Se vocês fizerem a seguinte declaração : Int x,y; Vai ocorrer um erro no momento da compilação do seu programa, já que o C não conhece o tipo Int com “I” maiúsculo. Fiquem atentos, pois esse é um erro comum para quem está começando a programar em C.

De acordo com o que foi visto, quando estudamos a estrutura da um programa C, as variáveis devem ser declaradas logo quando inicia o corpo do programa principal. Vamos estudar, a seguir, como fazemos para declarar as nossas constantes.

3.2.3. Declaração de Constantes

Diferente das variáveis, as constantes mantêm seu valor ao longo do programa. Para indicar ao compilador que se trata de uma constante, a diretiva de compilação #define é utilizada. Segue a sintaxe da declaração de uma constante.

Sintaxe

#define <identificador> <valor>

44

Programação I

Não é necessário colocar o ponto e vírgula no final da linha e também não precisa informar o tipo de dado da constante. O valor de uma constante não pode ser modificado, de maneira alguma, ao longo da execução do programa.

O modo como cada constante é representada depende do seu tipo. Constantes do tipo inteiro são representadas por números sem o componente fracionário, por exemplo, 123 e 2009. Constantes reais precisam do uso de ponto decimal seguido do componente fracionário do número, por exemplo, 302.54. Constantes caractere são colocadas entre apóstrofos, por exemplo, ‘a’. Constantes cadeia de caractere são colocadas entre aspas duplas, por exemplo, “Casa” e “Maria”. A seguir são apresentadas as declarações de quatro constantes:

Exemplo 3.2: Declaração de Constantes

1

2

3

4

#define DIAS 7

#define PI 3.1416

#define RESPOSTA ‘s’

#define DISCIPLINA “Matemática”

De acordo com o exemplo, a constante DIAS irá armazenar sempre 7. Como o valor que esta constante recebeu foi um valor inteiro, o compilador entende, automaticamente, que esta é uma constante inteira. Da mesma forma, como a constante PI recebeu 3.1416 (um número real), o compilador saberá que se trata de uma constante do tipo real. A constante RESPOSTA armazena um char e DISCIPLINA uma cadeia de caracteres.

É interessante declarar uma constante quando sabemos que um valor não será modificado ao longo da execução do programa. Por questões de padronização, declare as suas constantes com todas as letras em maiúsculo, como apresentado nos exemplos. Assim você estará diferenciando-as das variáveis.

De acordo com a estrutura de um programa C, as nossas constantes são declaradas no início do programa, logo após incluirmos as bibliotecas que serão utilizadas. Estão lembrados(as) disso? Se não estão, deem uma revisada na seção 2.1, certo?

Ao serem criadas, as constantes já recebem o valor que elas vão armazenar ao longo do programa. Isto não acontece com as variáveis.

45

Programação I

Mas como fazemos para armazenar um valor em uma variável? Esta resposta vocês encontrarão na próxima seção.

3.3. Operador de Atribuição (=)

Esse operador é utilizado para armazenar um valor em uma dada variável. Assim, o operador de atribuição nos possibilita armazenar um dado em um espaço de memória, que foi previamente declarado. É importante que o dado que será armazenado seja compatível com o tipo da variável que receberá a atribuição. Por exemplo, as variáveis reais podem receber valores reais e inteiros. No entanto, uma variável inteira não pode receber um valor real. Segue a sintaxe do operador de atribuição.

Sintaxe

Variavel = Valor;

Variavel_1 = Variavel_2;

Variavel = Expressão Aritmética;

Variavel = função;

Variavel_1 = variavel_2 = variavel_3 = valor;

O operador de atribuição é representado pelo símbolo =. No lado esquerdo do operador da atribuição, temos a variável que vai receber o valor. No lado direito do operador, temos o valor que será atribuído à variável. Ao final da linha de atribuição deve ter um ponto e vírgula.

Notem que o operador de atribuição permite várias possibilidades. Para um melhor entendimento, o exemplo 3.3 apresenta cada uma das possibilidades do operador de atribuição.

46

Programação I

Exemplo 3.3: Comando de atribuição

1

2

3

4

5

6

7

8

9

float Media, X, Y, Z;

int J, L, M, K, A, B;

char Letra;

Media = 7.5;

Letra = ’D’;

X = Y;

K = A + B;

Z = sqrt(4);

J = L = M = 10;

Nas linhas 1, 2 e 3, temos a declaração das variáveis. Lembrem que só podemos armazenar algum valor, caso tenhamos declarado as variáveis. Uma vez que é necessário ter reservado espaços de memória para nossos dados, entendido?

Na linha 4, a variável Media recebeu 7.5 (para números reais, devemos utilizar ponto ao invés de virgula, para separar a parte inteira da parte fracionária do número)19.

Na linha 5, temos uma atribuição para uma variável char com um único caractere. Note que, neste caso, o valor que a variável receberá vem entre apóstrofo. Assim, a variável Letra está recebendo D.

Atenção

O operador de atribuição não é usado para variáveis do tipo char com vários caracteres. Este tipo de atribuição será visto no capítulo “Comandos de Manipulação de Caracteres”, do Volume 4.

Na linha 6, a variável X receberá o valor que está armazenado na variável Y. Na linha 7, a variável K irá receber o resultado da

Saiba Mais

19Onde aparece o = do comando de atribuição, nos lemos: “recebe”. Assim, o comando da linha 4 do exemplo 3.3, seria lido: “Media recebe 7.5”.

47

Programação I

expressão A + B, ou seja, será obtido o valor armazenado na variável A, depois o valor da variável B, os valores são somados e o resultado é atribuído a variável K. Uma variável sempre recebe um valor. Quando a atribuição tem uma expressão matemática, a expressão é resolvida e o resultado é atribuído à variável.

Na linha 8, a variável Z receberá o resultado da chamada da função sqrt (que faz o cálculo da raiz quadrada de um número). Veremos mais detalhes sobre estas funções no capítulo 5.

Na linha 9, aparece o que chamamos de atribuição em cadeia. Quando várias variáveis vão receber o mesmo valor, ao invés de ser feita uma atribuição de cada vez, podemos dizer: variavel1 = variavel2 = variavel3 = valor. Nós podemos atribuir o mesmo valor a quantas variáveis quisermos. Coloquei um exemplo com três variáveis, certo? No exemplo da linha 9, as variáveis K, L e M vão receber 10. Mas tem um detalhe, nós só podemos usar a atribuição em cadeia quando todas as variáveis que irão receber o valor são do mesmo tipo. Assim, nesta atribuição do exemplo, as três variáveis K, L e M são do mesmo tipo: int.


Temos agora mais uma lista de exercícios para consolidar o nosso entendimento do assunto visto neste capítulo. Vocês perceberam quantas coisas novas nós já aprendemos até aqui? Como uma linguagem de programação envolve vários detalhes, são os exercícios que vão nos ajudar a não esquecer deles. Prontos (as) para acertar todas as questões?

1. Identifique os tipos dos valores abaixo (int, float, char de um caractere ou char de vários caracteres):

1) 1000 2) “09” 3) – 1.56 4) “VERDADE”

5) – 456 6) 34 7) ‘C’ 8) 45.8976

9) “BRASIL” 10) ‘l’ 11) - 5.6 12) 300

2. A seguir, temos exemplos de identificadores. Assinale os identificadores válidos e descreva o erro dos operadores inválidos.

48

Programação I

1) endereco 2) 21brasil 3) fone$com 4) nome_usuario

5) usuario6 6) nome*usuario 7) end*a-6 8) #media

9) nome aluno 10) média 11) _pais 12) Media_da_Turma

3. De acordo com as declarações abaixo, assinale os comando de atribuição inválidos e descreva o erro.

int NUM, X, SOMA;

float MEDIA, K, L;

( ) SOMA = NUM + 2;

( ) MEDIA = SOMA;

( ) NUM = K + L;

( ) X = X + 1

( ) L = SOMA - K;

( ) SOMA + 2 = NUM + 10;

( ) S = SOMA;

( ) X = SOMA - NUM;

Conheça Mais

Comece a aprofundar mais seus conhecimentos com a leituras dos livros clássicos da linguagem C:

O mais autêntico de todos, tem como autores os criadores desta linguagem: C - A Linguagem de Programação, de B. W. Kernighan e D. M. Ritchie, editora Campus. Este é um livro relativamente difícil de ler, mas é a “Bíblia” da linguagem.

Dois textos mais didáticos são:

C Completo e Total, de Herbert Schildt, pela editora MAKRON Books.

Como programar em C, de H. M. Deitel e P. J. Deitel, pela editora LTC.

49

Programação I

A vantagem de ver vários livros é que um autor acaba complementado o que o outro escreveu. Além disso, um autor pode explicar um certo assunto de forma mais clara que o outro. Por isso é bom sempre dar uma olhada em livros novos e materiais disponíveis na Internet.

Vamos revisar?

Vamos fazer uma revisão do assunto que foi visto neste capítulo, fazendo a leitura do resumo a seguir:

» Os tipos de dados manipulados pelo C são: inteiro, real, caractere e void.

» O tipo inteiro se divide em: int, short ou long. A diferença entre os três tipos é a quantidade de memória reservada para armazená-los.

» O tipo real se divide em: float e double.

» O tipo char armazena um caractere. Quando desejamos armazenar vários caracteres, para formar um nome ou frase, precisamos declarar uma cadeia de caracteres.

» As variáveis são espaços de memória onde armazenamos nossos dados. Uma variável possui um nome, um tipo e um valor.

» Para que um variável passe a existir, precisamos fazer a sua declaração. Ao declarar uma variável, damos a ela um nome, e informamos que tipo de dado pode ser armazenado na variável.

» Os nomes das variáveis são os identificadores. Para dar um nome a uma variável, precisamos seguir a regra de criação de identificadores.

» As constantes são espaços de memória onde armazenamos um valor que não será alterado durante a execução do programa.

» O comando de atribuição é utilizado quando desejamos armazenar um valor em uma variável.

» A atribuição de um valor a uma variável só poderá ser executada se o tipo de dado que a variável armazena for compatível com o valor que será atribuído.

50

Programação I

Capítulo 4 – Comandos de Entrada e Saída de Dados


Um programa que não fornece resultados, nem recebe valores para serem processados, não tem muita utilidade. De um modo geral, o objetivo pelo qual escrevemos programas é a obtenção de resultados (Saídas) depois da realização de cálculos ou pesquisas (Processamento) através do fornecimento de um conjunto de dados (Entradas). Neste capítulo, iremos a estudar os comandos de entrada e saída de dados. Assim, com o comando de entrada poderemos fornecer dados para que sejam processados pelo programa. Com o comando de saída poderemos receber os resultados do processamento dos nossos dados. Uma boa notícia é que, a partir deste capítulo, teremos adquirido conhecimento suficiente para construir um programa completo em C! Ficaram felizes? Então não vamos perder mais tempo, vamos logo aprender os comandos de entrada e saída de dados.

4.1. Entrada de Dados

O comando de entrada de dados é utilizado quando desejamos fornecer um valor para um nosso programa. A entrada de dados é feita através de um dispositivo de entrada de dados. Os dispositivos mais comuns são: teclado, mouse20, tela sensível ao toque, scanner, dentre outros. A figura 4.1 apresenta alguns destes dispositivos.

Figura 4.1: Dispositivos de Entrada de Dados

Saiba Mais

20Voce sabe quem inventou o mouse? Embora tenha sido inventado por Bill Enghlish, a sua patente pertence a Douglas Engelbart. Ele apresentou este periférico pela primeira vez em 1968 e o chamou de “XY Position Indicator For A Display System”. O primeiro mouse era feito de madeira, com apenas um botão. O invento de Engelbart ficou sem muita utilização devido a falta de necessidade de tal dispositivo, já que a maioria dos computadores utilizavam apenas textos sem cursores na tela. Vocês se imaginam sem um mouse em seus computadores?

51

Programação I

Nesta seção, iremos aprender como executar a entrada de um dado (ou a leitura de um dado, como também é chamada) através do teclado. A execução do comando de leitura pressupõe que os dados serão fornecidos do meio externo (teclado), e serão armazenados na memória (variáveis).

O comando que faz a leitura de um dado fornecido via teclado e o armazena em uma variável do programa é o scanf. Fazendo um paralelo com o Portugol, o scanf é o comando leia. Vamos ver a sua sintaxe.

Sintaxe

scanf(“string de controle”, &variavel);

O comando scanf tem um certo nível de detalhes, para entendê-lo, vamos por partes. Na primeira parte do scanf, entre as aspas, aparece a string de controle. O que vem a ser a string de controle? A string de controle indicará que tipo de dado será lido neste momento. A string de controle deve assumir um dos valores abaixo:

String de Controle Significado

%d leitura de números inteiros

%f leitura de números reais

%c leitura de um caractere

%s leitura de cadeia de caracteres

Assim, quando formos ler um dado que vai ser armazenado em uma variável do tipo inteiro, a string de controle deve ser “%d”. Se o valor a ser lido, for um número real, a string de controle será “%f”. Quando o dado a ser lido for um único caractere, a string de controle é “%c” e para ler uma cadeia de caracteres, é utilizado “%s”. Com a resolução de exercícios, vocês não esquecerão o significado de cada string de controle, certo?

Na segunda parte do scanf, colocamos o nome da variável que vai armazenar o valor que será fornecido via teclado, entendido? Notem que antes do nome da variável, aparece um & (e-comercial). O & faz parte da sintaxe do scanf e não pode ser esquecido. NUNCA! Na linguagem C, o & significa: “Endereço de memória”21. Assim, o comando scanf indica que o dado será lido via teclado e será

Saiba Mais

21Nós acessamos uma variável através do seu nome. No entanto, o processador acessa uma variável utilizando o endereço de memória dela. Cada variável criada no nosso programa possui um endereço de memória. Nós não precisamos conhecer o endereço de memória de uma variável, certo? Só precisamos saber o nome dela.

52

Programação I

armazenado no endereço de memória da variável. O comando scanf também termina com ponto e vírgula.

Vamos analisar o exemplo 4.1, que apresenta o uso do scanf.

Exemplo 4.1: Comando de Entrada - scanf

1

2

3

4

5

6

int idade;

float salario;

char letra, nome[20];

scanf(“%d”, &idade);

scanf(“%f”, &salario);

scanf(“%c”, &letra);

Nas linhas 1 a 3, temos as declarações das nossas variáveis. No scanf da linha 4, temos a leitura da variável idade. Como esta variável é do tipo int, a string de controle é “%d”. Na linha 5, temos a leitura da variável salário, que é do tipo float. Assim, a string de controle é “%f”. Por fim, na linha 6, temos a leitura da variável letra, que é do tipo char, contendo apenas um caractere. Por conta disso, a string de controle foi “%c”. A string de controle vem sempre entre aspas duplas, certo? Note que também foi declarada uma variável chamada nome, que é uma cadeia de 20 caracteres. No entanto, o comando scanf não funciona corretamente nas leituras de cadeias de caractere. Portanto, quando for necessário fazer a leitura de variáveis deste tipo, teremos que usar um outro comando, que será visto na próxima seção.

4.1.1. Entrada de Cadeia de Caracteres

Como mencionado, o comando scanf não funciona de maneira correta ao ler uma cadeia de caracteres. O problema é que, se nesta cadeia de caractere tiver um espaço em branco, separando uma palavra da outra, ao encontrar o espaço em branco, o processador entende que a leitura terminou, desprezando parte do nosso dado. Então já viu, não dá para ficar com o dado pela metade, não é mesmo?

A solução é usar outro comando de leitura, específico para a leitura de cadeias de caracteres. Este comando é o gets. A sintaxe do gets é a seguinte:

53

Programação I

Sintaxe

fflush(stdin);

gets(variável);

Para a execução de um gets, precisamos informar apenas a variável que irá receber o valor lido. Note também que antes do gets, temos o comando fflush. É assim mesmo. Sempre que tivermos um gets, antes temos que executar um fflush. Não esqueça disso, certo?

O comando fflush é um comando que limpa o buffer de entrada de dados (stdin). Estão querendo saber o que é o buffer de entrada? O buffer é um espaço de memória que armazena, temporariamente, os nossos dados. É assim, suponha que o programa está solicitando que seja digitado o nome do usuário. O usuário vai teclando cada letra que forma seu nome. Ao terminar de digitar, ele tecla enter. O enter indica ao processador que o usuário encerrou aquela entrada de dados. Enquanto não for teclado o enter, o processador vai armazenado cada tecla que está sendo pressionada, no buffer de entrada. Após o enter ser pressionado, o processador pega o nome completo do usuário, que está no buffer de entrada, e transfere para a variável.

Pode parecer complexo, mas não é. A questão é que, enquanto não terminamos de digitar o dado, ele está sendo formado. Só depois de finalizada a entrada, é que ele é pode ser transferido para a variável. A Figura 4.2 ilustra o esquema da entrada de dados.

4.2: Esquema da entrada de dados

A execução do fflush nos assegura que o buffer de entrada está limpo, sem o conteúdo de algum dado que foi teclado anteriormente.

54

Programação I

No caso de entradas de dados usando o scanf, não é necessário limpar o buffer de entrada.

Atenção

O gets e o fflush são comandos que se encontram em uma biblioteca chamada stdio.h. Portanto, se você for utilizar estes comandos, esta biblioteca deverá ser incluída na seção de inclusão de bibliotecas do programa. A inclusão é feita com a diretiva de compilação #include e fica assim: #include <stdio.h>.

Vamos agora analisar o exemplo 4.2, que apresenta o uso do comando gets.

Exemplo 4.2: Comando de Entrada - fgets

1

2

3

4

5

char nome_aluno[20], endereco[50];

fflush(stdin);

gets(nome_aluno);

fflush(stdin);

gets(endereco);

Na linha 1, temos as declarações das variáveis nome_aluno e endereco. A variável nome_aluno armazena até 20 caracteres e a variável endereco armazena até 50 caracteres. Antes de executar o gets da linha 3, responsável por ler o nome_aluno, temos, na linha 2, o fflush, responsável por limpar o buffer de entrada. Na sequência, temos a leitura da variável endereco. Assim, é necessária a execução de um novo fflush antes do gets da linha 5. Notem que na leitura de uma variável cadeia de caractere, só usamos o nome dela, desprezamos o colchetes e o número que indica quantos caracteres ela armazena.

Agora que sabemos como fazer a entrada de dados via teclado, vamos aprender a apresentar os dados na tela. Só falta este comando para darmos início a criação dos nossos programas. Estamos bem perto! Vamos em frente!

55

Programação I

4.2. Saída de Dados

O comando de saída de dados é utilizado quando desejamos ver o resultado do processamento do nosso programa. Este comando também é utilizado para passar mensagens na tela, solicitando que o usuário faça algo, como por exemplo, digitar a idade dele. Os dispositivos de saídas de dados mais comuns são: monitor, impressora e caixas de som. A figura 4.3 apresenta tais dispositivos.

Figura 4.3: Dispositivos de saída de dados

Vamos agora aprender o comando que fornece a saída de dados para o dispositivo de saída padrão que é a tela do computador. Este comando é o printf. Fazendo um paralelo com o Portugol, o printf é o comando escreva. Vamos ver a sua sintaxe.

Sintaxe

printf(“string de controle”);

printf(“string de controle”, lista de argumentos);

Existem duas sintaxes para o printf. Na primeira, só temos a string de controle, entre as aspas dupla. Usamos esta sintaxe quando queremos escrever apenas texto na tela. Na segunda, além da string de controle, temos a lista de argumentos. Esta sintaxe é aplicada quando iremos escrever texto e valores armazenados nas variáveis. Apesar de aparecer aqui uma string de controle, ela não é similar a do scanf, certo? No printf, a string de controle é uma “máscara” que especifica (formata) o que será impresso e de que maneira será impresso. Na string de controle pode conter: texto, códigos especiais e especificadores de formatos. Calma! Vamos detalhar mais.

Primeiramente, vamos ver quais são os códigos especiais que podem aparecer na string de controle do printf. Os códigos especiais são formados por uma barra invertida (\), seguida de uma letra. O código especial, indica uma ação que deve ser executada pelo printf.

56

Programação I

A tabela a seguir apresenta os códigos especiais e o seu significado.

Código Especial Ação

\n Muda o cursor para o início da linha seguinte.

\t tabulação (tab)

\” Escreve uma aspas dupla na tela

\\ Escreve uma barra invertida na tela

\a Dá um alerta sonoro

Vamos analisar exemplos bem simples de printf, que escrevem, apenas um texto na tela.

Exemplo 4.3: Comando de Saída – printf – Escrevendo textos apenas

1

2

3

4

printf(“Ola Mundo!”);

printf(“\nBom Dia...”);

printf(“\n\nIsso eh um teste.\a”);

printf(“\n\nAte \nmais... \ntchau”);

A execução desta sequência de printf do exemplo 4.3, resulta na seguinte tela (Figura 4.4).

Figura 4.4: Tela de execução de um programa: uso do printf

Vamos entender cada printf do exemplo 4.3. Um detalhe essencial que devemos saber: o printf escreve um texto na tela, a partir do ponto em que o cursor se encontra no momento. Quando um programa é executado, o cursor se encontra na primeira coluna, da primeira linha da tela22. No primeiro printf do exemplo, a string de controle tem

Saiba Mais

22 A tela tem as seguintes dimensões: 80 colunas x 25 linha. Assim, conseguimos escrever 80 caracteres em uma linha de tela. E conseguimos ter uma tela com até 25 linhas.

57

Programação I

apenas o texto que queremos colocar na tela: “Ola Mundo!”23. Após terminar este printf, o cursor estará posicionado após a exclamação.

Na sequência, na linha 2, temos um printf cuja string de controle é: “\nBom Dia...”. O \n serviu para fazer com que o cursor mudasse para o início da linha seguinte e logo em seguida, o texto “Bom dia..” foi impresso, e o cursor ficou no final desta linha.

No printf da linha 3, temos a string de controle: “\n\nIsso eh um teste.\a”. A string de controle começa com dois “\n”. Isso faz com que o cursor mude de linha duas vezes. Assim, teremos uma linha em branco na tela. Além disso, na string de controle, também temos um “\a”, que faz com que seja disparado um beep(sinal sonoro) quando este printf for executado. É interessante usar o sinal sonoro quando quisermos chamar a atenção do usuário.

Finalmente, na linha 4, temos o printf com a string de controle: “\n\nAte \nmais... \ntchau”. Como a string de controle começa com dois “\n”, o cursor muda de linha duas vezes, e escreve “Ate”. Na sequência, temos outro “/n”, o que fez o cursor mudar novamente de linha e escrever “mais...”. Por fim, temos outro “\n”, o cursor vai mudar de linha e escreve “tchau”. Notem que um único printf, pode resultar em um texto em várias linhas da tela. Isso não é possível no Portugol.

Vamos ver agora, como escrevemos textos e valores, armazenados nas nossas variáveis, na tela do computador. Para isto, temos que saber mais um detalhe que vai aparecer na string de controle, que são os especificadores de formato. Um especificador de formato marca o lugar e o formato de impressão das variáveis, contidas na lista argumentos (vejam a segunda sintaxe do printf). Deve haver um especificador de formato para cada variável a ser impressa. Todos os especificadores de formato começam com um %. Os especificadores de formato são apresentados na tabela a seguir.

Especificador de Formato Uso

%d Escrever um valor do tipo inteiro

%f Escrever um valor do tipo real

%c Escrever um caractere

%s Escrever uma cadeia de caracteres

%% Escrever o caractere ‘%’

Saiba Mais

23 Atenção: Não use acentos nos textos que serão escritos na tela. No volume 4, aprenderemos como acentuar nossos textos.

58

Programação I

Neste caso de impressão na tela, quando temos textos e valores, na string de controle, devemos colocar um especificador de formato, no ponto onde queremos que um valor seja impresso. O especificador deve ser relativo ao tipo de dado que será impresso. Após a string de controle, coloca-se uma vírgula, e na sequência vem a lista de variáveis que será impressa. Assim, nós primeiro montamos a frase (string de controle), informando em que ponto entrarão os valores (usando os especificadores de formato) e, depois, informamos quais variáveis serão utilizadas. Vamos ver alguns exemplos.

Exemplo 4.4: Comando de Saída – printf – Escrevendo textos e valores

1

2

3

4

5

6

7

8

9

10

int X, Y, mat, idade;

float A;

X = 1;

Y = 3;

A = 7.5;

mat = 123;

idade = 25;

printf(“O valor de A = %f”, A);

printf(“\n\nO aluno de matricula %d tem %d anos”, mat, idade);

printf(“\n\nResultado da soma: %d”, X+Y);

A sequência do exemplo 4.4 é iniciada com a declaração das variáveis e com a atribuição de valores, para que possamos entender melhor a montagem dos printf. No primeiro printf, da linha 8, queremos que seja apresentado o valor da variável float A. Assim, montamos a string de controle, informando o ponto da frase onde deve ser colocado o valor da variável A, utilizando o especificador de formato de valores reais, o “%f”. Veja na Figura 4.5, a tela resultante da execução desta sequência de comandos.

59

Programação I

Figura 4.5: Tela de execução de um programa usando printf com textos e valores

Quando pedimos para que um número real seja apresentado na tela, este é mostrado com uma precisão de seis casas decimais. Por isso, o valor da variável A, aparece como 7.500000. Podemos decidir quantas casas decimais devem ser apresentadas, uma vez que nem sempre queremos trabalhar com tantas casas decimais, bem como, poderemos precisar trabalhar com um número maior de casas decimais. Aprenderemos daqui a pouco como informar quantas casas decimais devem ser apresentadas, quando um número real for impresso na tela. Por enquanto, vamos continuar a análise do exemplo 4.4, certo?

No segundo printf, na linha 9, queremos que seja apresentado o número de matrícula do aluno e a sua idade. Aqui temos um printf que irá apresentar mais de um valor. O raciocínio é o mesmo. Montamos a string de controle, informando onde vai aparecer o valor das variáveis, utilizando o especificador de formato. O que muda é depois da string de controle. Após a vírgula, devemos colocar as variáveis que serão impressas, na ordem que elas devem aparecer na frase. Ou seja, se na ordem da frase, vem primeiro a matrícula do aluno, então, coloca-se primeiro a variável mat. Quando temos mais de uma variável, elas são separadas por vírgula. Notem que continuamos usando os códigos especiais na string de controle, neste caso foi colocado o “/n”, para mudar o cursor de linha.

Na linha 10, temos um printf que irá apresentar o resultado de um expressão matemática. Isto também é possível. Assim, na parte do printf que indicamos a variável que será impressa, nós colocamos a expressão matemática. A expressão é resolvida e o seu resultado é apresentado na tela.

Vamos ver agora como fazer para que nossos números reais sejam apresentados com a quantidade de casa decimais que quisermos. O que vai mudar é o especificador de formato dos números reais, o “%f”. Agora ele deve ser assim: entre o “%” e o “f”, colocaremos um ponto,

60

Programação I

seguido de um número, que representa quantas casas decimais nós queremos que sejam apresentadas. Vejam os printf do exemplo 4.5.

Exemplo 4.5: Comando de Saída – printf – formatando números reais

1

2

3

4

5

6

7

float A, B,C;

A = 3.4;

B = 1.12345;

C = 7.56789;

printf(“A = %.1f”, A);

printf(“\n\nB = %.2f”, B);

printf(“\n\nC = %.2f”, C);

Primeiro, temos as declarações e atribuições para três variáveis reais. Na linha 5, temos o printf que imprime o valor da variável A, vejam como ficou o especificador de formato: “%.1f”. Neste caso, queremos que seja apresentada apenas uma casa decimal deste número. Vejam a Figura 4.6, que apresenta a tela resultante da execução desta sequência de comandos.

Figura 4.6: Tela de execução de programa: formatação de números reais

Nas linhas 6 e 7, temos os printf que imprimem os valores das variáveis B e C. Neste caso, queremos que sejam apresentadas duas casas decimais, por isso, o especificador de formato ficou: “%.2f”. Só vamos ver mais um detalhe. Notem que, quando pedimos para que um número seja apresentado com poucas casas decimais, o printf apresenta um valor arredondado. Como assim? Veja o valor que foi atribuído a variável C, na linha 4 do exemplo: 7.56789. Veja

61

Programação I

agora o valor que foi apresentado na tela de execução do programa: 7.57. Funciona assim: se queremos que sejam apresentadas apenas duas decimais, o printf vai verificar qual valor tem na terceira casa decimal, se tiver um valor maior ou igual a cinco, ele arredonda o valor apresentado. Se for um número menor que 5, ele não arredonda. Observe o valor da variável B.

Terminamos aqui os comandos de entrada e saída. Como estes comandos tem muitos detalhes, ficamos sujeitos a cometer vários erros quando os utilizamos: esquecer uma vírgula, uma aspa, dentre outros. Na próxima seção, iremos ver uma lista dos erros mais comuns que ocorrem com o uso destes comandos. Com esta lista, poderemos encontrar os erros dos nossos programas mais rapidamente, certo?

4.3. Erros Frequentes no Uso dos Comandos de Entrada e Saída

Nesta seção, será apresentada uma lista com os erros que são mais frequentemente cometidos por quem está iniciando a programar, e que precisa ficar atento a tantos detalhes da sintaxe dos comandos. Vamos ver, na tabela abaixo, os erros que podemos cometer no uso do scanf, gets e printf.

Comando Erros Consequência

Scanf Esquecer o & antes do nome da variável.

O programa compila, como se não tivesse erro, mas durante a execução ele trava.

Trocar a string de controle. Por exemplo, no lugar de um %d, usar um %f.

O programa compila, mas a variável receberá um valor esquisito (normalmente, um valor bem grande)

Esquecer o ; no final do comando.

O compilador avisa que tem erro.

Esquecer as aspas da string de controle.


Esquecer a vírgula entre a string de controle e a variável.


Fazer a leitura de uma variável que não foi declarada.


62

Programação I

Gets Esquecer de colocar o comando fflush antes do gets.

O programa compila, como se não tivesse erro, mas durante a execução, o processador pula a execução do comando gets.

Esquecer de incluir a biblioteca stdio.h.


printf Não fechar a string de controle.


Esquecer a vírgula entre as variáveis que serão impressas.


Usar um especificador de formato incompatível com o valor que será impresso.

O programa compila, mas será impresso um valor esquisito.

Esquecer de colocar um especificador de formato.

O programa compila, mas não imprime o valor da variável.

Notem na coluna “consequência”, que mesmo que sejam cometidos alguns tipos de erros, o programa vai compilar e só durante a execução é que notaremos algo estranho. Atenção: podem ocorrer outros erros que não foram mencionados nesta lista, estes são apenas os mais comuns.

Pronto, enfim poderemos começar a fazer os nossos primeiros programas! Já sabemos declarar variáveis, atribuir valores a elas, ler valores via teclado e apresentar resultados na tela. Com esses comandos, já podemos fazer uns programas simples em C. Para começar, vocês já tem devem ter instalado o Dev-cpp nos seus computadores. Na próxima seção, veremos dois programas completos comentados. Agora é de verdade, vamos programar!

4.4. Primeiros programas em C

É isso, vamos começar com o nosso primeiro programa em C. Ele será simples, mas com o tempo iremos aumentado o nível de complexidade dos nossos programas. Antes de tudo, vamos a alguns detalhes (Mais detalhes?). Primeiro, vocês devem executar o Dev-cpp e escolher a opção: Arquivo/Novo/Arquivo Fonte. NÃO devemos trabalhar com projetos, certo? Em seguida, comecem a digitar o programa.

63

Programação I

Atenção

Por padrão, o Dev-cpp salva os nossos programas no formato do c++ (ou seja, .cpp). Sempre que forem salvar os programas, lembrem de informar que vocês querem que este seja salvo no formato .c. Fiquem atentos a isso!

A Figura 4.7 mostra a tela de como devemos salvar nossos programas. No momento que solicitamos que o programa seja salvo, é aberta uma janela para escolha do diretório que o programa será salvo, o nome dele e podemos também escolher o formato, na opção: “Save as Type”. Nesta opção, você deve escolher: “C source files (*.c)”. Só isso. Se você salvar seu programa como .cpp, ele ficará dando erros.

Figura 4.7: Tela do Dev-cpp: salvando um programa c.

O nosso primeiro programa em C irá ler dois números inteiros e apresenta a soma destes dois números. Segue abaixo o programa completo. Em seguida, vamos comentar cada linha.

64

Programação I

Programa Completo 4.1: Ler dois números inteiros e calcula a soma

1

2

3

4

5

6

7

8

9

10

11

12

13

//Ler dois numeros e calcula a soma

main()

{

int n1, n2, soma;

printf(“Calcular a soma de dois numeros\n\n”);

printf(“Primeiro valor: “);

scanf(“%d”, &n1);

printf(“Segundo valor: “);

scanf(“%d”, &n2);

soma = n1 + n2;

printf(“\n\nA soma dos dois numeros = %d\n\n”,soma);

system(“pause”);

}

Comentários sobre cada linha do Programa completo 4.1

» Linha 1: De acordo com a estrutura de um programa C, este inicia com inclusão das bibliotecas, quando necessário. Neste exemplo, não utilizamos nenhum comando que se fez necessária a inclusão de biblioteca. Assim, na linha 1 temos um comentário, indicando o que o programa faz. Sempre coloquem esse tipo de comentário no programa. Assim, ele ficará bem documentado.

» Linha 2: início do programa principal, que é definido pelo: “main()”.

» Linha 3: temos um abre chaves, que irá delimitar o corpo do programa principal.

» Linha 4: temos as declarações das três variáveis do programa24:

Saiba Mais

24Ao ler um enunciado de uma questão procure identificar as variáveis de entrada, ou seja, quais valores serão fornecidos pelo usuário e qual resultado o programa precisa processar. E assim, faça a declaração das suas variáveis.

65

Programação I

n1 e n2 (para armazenar os números que serão fornecidos pelo usuário) e soma (que armazena a soma dos dois números).

» Linha 5: um printf que serve para colocar, no início da tela, o título do que o programa faz. Isso é importante para que o usuário saiba para que serve o programa.

» Linha 625: colocamos este printf para que o usuário saiba que precisa fornecer o primeiro valor.

» Linha 7: scanf que lê o primeiro valor e armazena na variável n1.

» Linha 8: printf para que o usuário saiba que precisa fornecer o segundo valor.

» Linha 9: scanf que lê o segundo valor e armazena na variável n2.

» Linha 10: agora que já temos os dois valores armazenados nas variáveis n1 e n2, podemos executar a soma. Nesta linha, temos o comando que atribui a soma das variáveis n1 e n2 para a variável soma.

» Linha 11: printf que apresenta o resultado, que está armazenado na variável soma.

» Linha 12: nesta linha, temos um comando novo. É o seguinte, assim que é terminada a execução do nosso programa, o processador fecha, automaticamente, a janela onde o programa estava sendo executado. Por conta disso, acabamos sem ver algum resultado que tenha sido impresso na tela. Para fazer com que a janela não feche ao término da execução, foi colocado o comando system(“pause”). Este comando dá uma pausa na execução do programa e fica aguardando que o usuário pressione alguma tecla26. Com esta pausa, poderemos ver os resultados apresentados. Assim que pressionamos algo no teclado, a janela irá fechar. Portanto, no final dos nossos programas, teremos que colocar o system(“pause”), certo? Um outro comando que faz a mesma coisa é o getche(), no próximo exemplo, usaremos o getche(), para que vocês possam conhecê-lo.

» Linha 13: fecha chaves, indicando o final do programa principal.

Importante

25 Sempre que temos que fazer uma leitura de dados (com scanf ou gets), devemos colocar uma mensagem para que o usuário saiba o que ele deve digitar. Assim, todo scanf (ou gets), deve ter um printf antes, informado o que o usuário tem que fazer. O programa precisa se comunicar com o usuário.

Saiba Mais

26O comando system(“pause”) escreve na tela de execução do programa a seguinte mensagem: “Press any key to continue...” ou “Pressione qualquer tecla para continuar...”

66

Programação I

Vocês devem digitar, compilar e executar este programa utilizando o Dev-cpp. Comecem a se familiarizar com a sintaxe do C. Também procurem se familiarizar com o ambiente de programação. Em breve, vocês não estarão mais tendo que consultar as sintaxes dos comandos com tanta frequência. Vamos logo fazer outro programa!

Nosso segundo programa irá ler o nome do usuário e o ano em que ele nasceu e como resultado imprime uma mensagem dizendo quanto anos o usuário tem.

Programa Completo 4.2: Ler o nome e a idade do usuário e informar a sua idade.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

#include <stdio.h>

//Ler o nome e a idade do usuário e informar a sua idade.

main()

{

char nome[20];

int ano, idade;

printf(“Calcular a idade o usuario\n\n”);

printf(“Seu nome: “);

fflush(stdin);

gets(nome);

printf(“Ano que voce nasceu: “);

scanf(“%d”, &ano);

idade = 2009 - ano;

printf(“\n\n%s, voce esta com %d anos.”, nome, idade);

getche();

}

67

Programação I

Programa Completo 4.2: Ler o nome e a idade do usuário e informar a sua idade.

Vamos ver o que está sendo feito em cada linha do programa completo 4.2.

» Linha 1: Neste programa nós teremos que ler uma variável que é uma cadeia de caractere: o nome do usuário. Assim, precisaremos usar o gets e o fflush. Estes comandos ficam na biblioteca stdio.h. Na linha 1, temos a inclusão desta biblioteca.

» Linha 2: Comentário indicando o que o programa faz.

» Linha 3: início do programa principal, que é definido pelo: main().

» Linha 4: temos um abre chaves, que irá delimitar o corpo do programa principal.

» Linha 5: declaração da variável do tipo char, que armazena o nome do usuário.

» Linha 6: declaração das variáveis inteiras: ano (que armazena o ano de nascimento do usuário) e idade (que armazenará a idade do usuário, que será calculada pelo programa).

» Linha 7: printf que indica o que o programa faz, no início da tela de execução.

» Linha 8: printf que solicita que seja digitado o nome do usuário.

» Linha 9: temos o comando fflush, que DEVE sempre vir antes do comando gets.

» Linha 10: gets que efetuará a leitura do nome do usuário.

» Linha 11: printf para que o usuário saiba que precisa fornecer o ano de nascimento.

» Linha 12: scanf que lê o ano de nascimento do usuário.

» Linha 13: atribuição que descobre quantos anos o usuários tem. Para isso, subtraímos o ano atual (2009), do ano que o usuário nasceu. O resultado é atribuído para a variável idade.

» Linha 14: printf que apresenta o resultado. Notem que o nome do usuário vai aparecer na frase. A string de controle começa no dois “\n”, solicitando que o cursor mude de linha e logo temos

68

Programação I

um “%s”, isto é porque queremos que a resposta seja iniciada com o nome do usuário. Um exemplo de frase de resposta é: “Carolina, você esta com 10 anos”.

» Linha 15: temos o comando getche(), similar ao system(“pause”), faz com que a tela de execução não feche ao final do programa. A vantagem do getche() é que ele não escreve nada na tela. Lembram que o system(“pause”) coloca uma frase na tela?


A seguir, temos as telas de execução dos programas completos 4.1 e 4.2.

Tela de execução do Programa completo 4.1

Tela de execução do Programa completo 4.2

Figura 4.8: Telas de execução dos programas completos 4.1 e 4.2

Com esses dois programa completamente comentados, já dá para vocês começarem a treinar sozinhos. Não queiram acertar tudo de primeira, vão com calma e sejam persistentes. Vejam que a sintaxe da linguagem C é cheia de detalhes que precisamos ter muita atenção. Na próxima seção, vocês encontrarão sugestões de exercícios.


Como vocês já devem ter notado, uma linguagem de programação envolve muitos detalhes. Vocês só irão aprender realmente, se fizerem muitos exercícios. É a prática que fará com que esta gama de detalhes seja assimilada. Portanto, aqui vai mais uma lista de exercícios. Esta é para ser resolvida no computador, certo? Podem começar a ligar seus computadores!

69

Programação I

1. Faça um programa que leia dois números reais A e B e os imprima na tela. O valor da variável A deve ser apresentado com duas casa decimais e o valor da variável B com três casas decimais.

2. Faça um programa que leia o nome do usuário e escreva uma frase de saudação, desejando um bom dia de trabalho para o mesmo. A resposta deve ter o formato deste exemplo: “Ola Joao, tenha um otimo dia de trabalho!”. Faca o programa soar um sinal sonoro(beep) ao escrever esta frase.

4. Faça um programa que leia dois números inteiros A e B e imprima o resultado da subtração de A por B. A resposta deve ter o seguinte formato: “6 – 2 = 4”.

3. Faca um programa que leia o nome do usuário e a sua idade e imprima quantos anos ele terá em 2020. A resposta deve ter o formato deste exemplo: “Carlos, em 2020 voce estara com 45 anos”.

5. Faça um programa que leia o nome do usuário, a idade do usuário, o nome da mãe do usuário e a idade da mãe do usuário. O programa deverá imprimir na tela quantos anos a mãe do usuário tinha quando ele nasceu. A resposta deve ter o formato deste exemplo: “Carlos, quando voce nasceu, Dona Cecilia tinha 27 anos”.

Conheça Mais

Aumente os seus conhecimentos sobre comandos de entrada e saída de dados acessando site especializados na linguagem C. Muitos professores e instituições disponibilizam materiais na rede e o principal, vocês podem encontrar muitos enunciados de exercícios.

Vocês já se inscreveram em um fórum de discussão da linguagem de programação C? Nessa fase em que estamos iniciando a programar, ter auxílio de programadores experientes é muito importante. Não deixem de se inscrever, certo?

70

Programação I

Vamos revisar?

Para dar uma revisada nos tópicos tratados neste capítulo, leiam o resumo a seguir:

» Dispositivos de entrada: são utilizados para passar informações para o computador. São exemplos de tais dispositivos: teclado e mouse.

» Dispositivos de saída: são utilizados para apresentar informações processadas pelo computador.

» scanf: um dos comandos de leitura do C. Este comando não é adequado para a leitura de cadeia de caracteres.

» gets: comando específico para a leitura de cadeia de caracteres. Para utilizá-lo, é necessário incluir no programa a biblioteca stdio.h.

» fflush: comando que faz a limpeza do buffer de entrada de dados. Sempre que fizermos uma leitura de cadeia de caracteres, devemos colocar o comando fflush.

» printf: comando de saída de dados. O printf pode ser usado para imprimir textos, valores de variáveis e resultados de expressões aritméticas.

» getche() e system(“pause”): comandos para provocar uma parada na tela de execução, fazendo com que o usuário possa conferir o resultado processado pelo programa.

71

Programação I

Capítulo 5 – Operadores, Expressões e Funções Matemáticas


Gostaram de ter feito os primeiros programas em C? Foram programas simples, que utilizavam o assunto visto até o momento. Vamos continuar avançando no estudo da linguagem C e aumentando, gradativamente, o nível de complexidade dos nossos programas. Neste capítulo, iremos aprender quais operadores estão disponíveis na linguagem C e como utilizá-los, através da montagem de expressões aritméticas, relacionais e lógicas. Também iremos abordar as principais funções da biblioteca matemática. Com o assunto deste capítulo, teremos habilidades para resolver questões que requerem a construção de expressões, seja aritmética, relacional ou lógica. Vamos em frente!

5.1. Operadores Básicos

Em toda linguagem de programação, existem operadores que nos permitem armazenar, modificar, comparar e avaliar dados no computador. Aqui veremos três tipos de operadores: aritméticos, relacionais e lógicos. Nas próximas seções, será feito o detalhamento de cada um dos tipos de operadores.

5.1.1 Operadores Aritméticos

Usamos os operadores aritméticos quando precisamos executar operações aritméticas (matemáticas) sobre os nossos dados (variáveis). A tabela abaixo apresenta os operadores aritméticos do C. Notem que o operador da multiplicação é um asterisco.

Operador Descrição

+ Adição

- Subtração

* Multiplicação

72

Programação I

/ Divisão

% Retorna o resto da divisão inteira de a por b

( ) Parênteses

Vamos dar uma atenção especial aos operadores da divisão(/) e resto(%). O resultado de uma divisão, em C, depende dos tipos dos dados que estão sendo divididos. A tabela abaixo apresenta o resultado da operação de divisão, de acordo com os tipos de dados do numerador e do denominador.

numerador / denominador resultado

inteiro / inteiro inteiro

inteiro/ real real

real / inteiro real

real/real real

Quando dois números inteiros são divididos, o resultado é a parte inteira do quociente da divisão. Quando pelo menos um dos elementos (numerador e/ou denominador) é real, o resultado é um número real. Vamos analisar a sequência de comandos a seguir:

Exemplo 5.1: Uso de Operadores Aritméticos

1

2

3

4

5

6

7

8

9

int X, Y, Z, W;

float K, L, M;

X = 19;

Y = 3;

Z = X/Y;

W = X % Y;

K = 19;

L = 3;

M = K/L;

73

Programação I

Nas linhas 1 e 2, temos as declarações das variáveis: quatro inteiras (X, Y, Z e W) e três reais (K, L, e M). Nas linhas 3 e 4 são atribuídos valores nas variáveis X e Y, que passam a armazenar tais valores. Na linha 5, temos um comando de atribuição, em que a variável Z receberá o resultado da divisão entre a variável X (19) e a variável Y (3). Como as variáveis X e Y são inteiras, o resultado será a parte inteira do quociente da divisão. Assim, se temos: 19/3 = 6.333333, será considerado apenas a parte inteira do resultado, ou seja, 6. Portanto, nesta atribuição da linha 5, a variável Z vai receber 6.

Na linha 6, a variável W vai receber o resto da divisão de X por Y, ou seja, o resto da divisão de 19 por 3. A figura 5.1 ilustra como a operação do resto é feita.

Figura 5.1: Resto de uma divisão

A operação do resto funciona da seguinte forma: os dois números vão sendo divididos, neste caso: 19 é dividido por 3 (primeiro quadro da figura 5.1). Assim, 19 por 3 dá 6 e sobra 1. Como o 1 não dá pra ser dividido por 3, a conta para e pega o resto da divisão que é 1. Portanto, o resultado da operação X%Y (neste caso, 19%3) é 1. Este resultado será atribuído a variável W.

Atenção

O operador do resto (%) só pode ser usado quando as variáveis envolvidas são do tipo inteiro. Não poderemos usar tal operador para obter resto de divisão de números reais. Outra coisa: o operador % não tem nada haver com percentagem, certo?

Nas linhas 7 e 8, são atribuídos valores nas variáveis K e L, que passam a armazenar tais valores. Na linha 9, temos um comando

74

Programação I

de atribuição, em que a variável M receberá o resultado da divisão entre a variável K (19) e a variável L (3). As variáveis K e L são reais (float). Dessa forma, teremos 19/3 = 6.333333. O resultado completo será atribuído a variável M, ou seja 6.33333, sem desprezar a parte fracionária do resultado.

A figura 5.2 apresenta o valor que ficou armazenado em cada uma das variáveis, após a execução da sequência de comandos. Note que, nas variáveis reais, mesmo que seja atribuído um valor inteiro, como por exemplo, na linha 7, que foi atribuído 19 à variável K, no momento que o valor é armazenado, ele passa a ter a parte fracionária do número. Por isso, a variável K aparece com 19.000000 de conteúdo (lembrem-se que o ponto deste número, está representando uma virgula, certo?).

Figura 5.2: Resultado final das variáveis

5.1.1.1 Prioridade dos Operadores

Uma questão que devemos tomar bastante cuidado ao montar uma expressão aritmética é a prioridade dos operadores. A prioridade que o operador aritmético tem sob o outro é que vai determinar como a expressão será resolvida. Na matemática, quando montamos uma expressão, usamos parênteses, colchetes e chaves. Nas linguagens de programação, nós só temos os parênteses.

Os parênteses têm um papel importante nas expressões e possibilitam que a ordem das operações seja alterada. Expressões entre parênteses são calculadas primeiro, portanto eles fornecem o maior grau de prioridade às expressões que envolvem. Podemos ter pares de parênteses envolvendo outros pares. Dizemos que os parênteses estão aninhados. Neste caso, as expressões dentro dos parênteses mais internos são avaliadas primeiro.

75

Programação I

A tabela abaixo apresenta a prioridade de resolução dos operadores aritméticos:

Prioridade Operador

1º Operações embutidas em parênteses “mais internos”

2º % (resto) e/ou * (multiplicação) e/ou / (divisão)

3º + (adição) e/ou – (subtração)

De acordo com a tabela, as expressões entre parênteses tem maior prioridade, portanto, são resolvidas primeiro. Na sequência, resolve os operadores resto e/ou multiplicação e/ou divisão, e, finalmente, resolve os operadores de adição e/ou subtração. Quando aparecem operadores de mesma prioridade em uma expressão, o operador mais à esquerda será avaliado primeiro.

Vamos analisar o exemplo 5.2, a seguir, e verificar qual o valor final das variáveis A, B, C e D.

Exemplo 5.2: Prioridade de Operadores

1

2

3

4

5

6

7

8

9

int X, Y, Z, W, A, B, C, D;

X = 19;

Y = 3;

Z = 4;

W = 2;

A = X + Y * Z;

B = (X + Y) * Z;

C = X – Y * Z / W;

D = (X-Y) * (Z/W);

Na linha 1, temos as declarações das variáveis que serão usadas (todas elas são do tipo int). Nas linhas 2 a 5, são atribuídos valores às variáveis X, Y, Z e W. Vamos acompanhar a resolução de cada expressão das linhas 6 a 9 na figura 5.3. A parte da expressão que

76

Programação I

aparece circulada, é a que tem prioridade de resolução.

Figura 5.3: Acompanhamento da resolução das expressões aritméticas

No primeiro quadro (atribuição para a variável A), aparecem na expressão os operadores da adição e multiplicação. Como a multiplicação tem prioridade, esta é resolvida primeiro. Posteriormente, o operador da adição é resolvido e assim o resultado que será atribuído à variável A.

No segundo quadro (atribuição para a variável B), a expressão também é composta por operadores de adição e multiplicação. No entanto, a adição aparece entre parênteses. Sabe-se que a operação dentro dos parênteses terá prioridade. Assim, a adição é resolvida e, posteriormente, a multiplicação.

No terceiro quadro (atribuição para a variável C), aparecem na expressão os operadores de subtração, multiplicação e divisão. O operador de subtração é o de menor prioridade. No entanto, os operadores de multiplicação e divisão tem a mesma prioridade. Dessa forma, o operador da multiplicação será resolvido primeiro, já que ele aparece mais à esquerda da expressão. Na sequência, a divisão é resolvida. E, finalmente, a subtração.

Finalmente, no quarto quadro (atribuição para a variável D), aparecem na expressão os operadores de subtração, multiplicação, divisão e parênteses. Primeiro, é resolvida a expressão dentro do parêntese mais à esquerda. Posteriormente, a expressão entre parênteses mais à direita. Finalizando com a resolução da multiplicação.

77

Programação I

5.1.2 Operadores Relacionais

Os operadores relacionais são utilizados para comparar valores de variáveis ou expressões aritméticas. Uma expressão aritmética tem como resultado um valor numérico. No caso de uma expressão relacional, o resultado será sempre um valor lógico: “Verdade” ou “Falso”. Na tabela abaixo são apresentados os operadores relacionais do C.

Operador Descrição

== Igualdade

!= Diferença (≠)

< Menor

> Maior

<= Menor ou Igual (≤)

>= Maior ou Igual (≥)

Vamos aprender como montar uma expressão relacional. Segue abaixo as possíveis sintaxes de expressões relacionais.

Sintaxe

Variavel operador Valor

Variável1 operador variável2

Variavel operador Expressão Aritmética

Expressão Aritmética operador Expressão Aritmética

Notem que podemos montar a expressão relacional de várias formas. Na tabela abaixo são apresentados exemplos de expressões relacionais.

Exemplo 5.3: Expressões relacionais

1

2

3

4

X == 10

X > Y

X < Y + Z

X * Y > Z / W

78

Programação I

Na linha 1, temos uma expressão relacional que verifica se a variável X é igual a 10 (ou ela será igual a 10 ou não, resultando em verdade ou falso). Na linha 2, temos uma expressão relacional que compara duas variáveis. Esta expressão verifica se o valor da variável X é maior que o valor da variável Y. Na linha 3, a expressão relacional compara o valor da variável X com o resultado da expressão aritmética Y + Z. Por fim, na linha 4, temos uma expressão relacional que compara o resultado de duas expressões aritméticas.

Suponha que X = 1, Y = 5, Z = 8 e W = 2. Vamos ver o resultado das expressões do exemplo 5.3 (V é verdade e F é falso):

Resultados das expressões relacionais do exemplo 5.3

1

2

3

4

X == 10 => 1 == 10 => F

X > Y => 1 > 5 => F

X < Y + Z => 1 < 5 + 8 => 1 < 13 => V

X * Y > Z / W => 1 * 5 > 8 / 2 => 5 > 4 => V

Quando as expressões relacionais são compostas por expressões aritméticas (como os exemplos das linhas 3 e 4), a prioridade de resolução é da expressão aritmética. Assim, primeiro resolve-se a expressão aritmética e a comparação é feita com o resultado da mesma.

5.1.3 Operadores Lógicos

Os operadores lógicos servem para interligar duas ou mais expressões relacionais. Uma expressão lógica representa a união de expressões relacionais, permitindo que os resultados de várias expressões relacionais sejam transformados em um único resultado lógico (verdade ou falso).

Os operadores lógicos são: E, OU e NÃO. A tabela a seguir apresenta como os operadores lógicos são representados na linguagem C.

79

Programação I

Operador Lógico Operador Lógico em C

E &&

OU ||

NÃO !

Os resultados das expressões lógicas obedecem às tabelas que veremos a seguir, que dependem dos resultados das expressões relacionais envolvidas. Quando montamos uma expressão lógica, as expressões relacionais devem ser colocadas entre parênteses.

Começaremos estudando a tabela de resultados do operador lógico E. Quando este operador interliga duas expressões relacionais, o resultado da expressão lógica só será verdade se as duas expressões relacionais forem verdade. Em qualquer outra situação, o resultado será falso.

Tabela de Resultado do Operador Lógico E (&&)

Expressão Relacional 1 Expressão Relacional 2 Resultado

V V V

V F F

F V F

F F F

Vejamos um exemplo: um aluno só será aprovado se a sua média for maior ou igual a 7. E, se a quantidade de faltas for menor que 15. As duas condições precisam ser verdade, para o aluno ser aprovado. Se o aluno tem a média maior que 7, mas tem mais de 15 faltas, ele não será aprovado. A expressão lógica para testar esta situação é apresentada na linha 1 do exemplo 5.4, a seguir.

Exemplo 5.4: Expressões Lógicas com operador e (&&)

1

2

3

(media >= 7.0) && (faltas < 15)

(A < 5) && (B <> 5)

(X > 10) && (Y > 50) && (Z < 25)

80

Programação I

Quando temos mais de duas expressões relacionais, como é o caso do exemplo da linha 3, a expressão lógica vai sendo resolvida da esquerda para a direita. Para acompanhar a resolução das expressões do exemplo, vamos supor que: media = 8.0, faltas = 18, A=3, B=4, X = 15, Y= 70 e Z=30. Vejamos a figura 5.4 a seguir.

Figura 5.4: Resultado das expressões lógicas do operador &&

No primeiro quadro da figura, a primeira expressão relacional é verdade e a segunda expressão é falsa. De acordo com a tabela de resultados do operador lógico E, verdade && falso dá falso. No segundo quadro, as duas expressões relacionais são verdade. Assim, de acordo com a tabela de resultados do operador lógico E, verdade && verdade dá verdade. Finalmente, no terceiro quadro temos três expressões relacionais. Neste caso, iremos resolver a expressão lógica, da esquerda para a direita. Começamos encontrando o resultado da primeira expressão relacional, com a segunda (ou seja, (X>10) && (Y>50)). E depois, pegamos este resultado e continuamos resolvendo o restante da expressão, sempre da esquerda para a direita. Podemos interligar vária expressões relacionais, através dos operadores lógicos.

Agora vamos analisar a tabela de resultados do operador lógico OU. Quando tivermos duas expressões relacionais interligadas pelo operador lógico ou, o resultado da expressão lógica só será falso se as duas expressões relacionais forem falsas. Nos demais casos, o resultado da expressão será verdade.

Tabela de Resultado do Operador Lógico OU (||)

Expressão Relacional 1 Expressão Relacional 2 Resultado

V V V

V F V

F V V

F F F

81

Programação I

Vejamos um exemplo: para o aluno ingressar em um curso superior - ele deve ser aprovado no vestibular OU ele deve ser um portador de diploma. Apenas uma situação precisa ser verdade. Assim, se o aluno nem passou no vestibular, nem é portador de diploma, não poderá ingressar no curso. A expressão lógica para testar esta situação é apresentada na linha 1 do exemplo 5.5, a seguir. Vejam outros exemplos de expressões lógicas com o operador OU.

Exemplo 5.5: Expressões Lógicas com operador ou (||)

1

2

3

(Aprove_Vestibular == ‘S’) || (Portador_Diploma == ‘S’) (A < 3) || (B < 2)

(X < 12) || (Y > 1) || (Z < 35)

A tabela de resultados do operador lógico NÃO é apresentada a seguir. Notem que a finalidade deste operador é inverter(ou negar, como é comumente chamado) o resultado de uma expressão relacional. Assim, se a expressão relacional é verdade, a sua negativa é falso.

Tabela de Resultado do Operador Lógico Não (!)

Expressão Relacional Resultado

V F

F V

No exemplo 5.6, temos duas expressões lógicas com o operador NAO. Este operador deve ser colocado na frente da expressão relacional.

Exemplo 5.6: Expressões Lógicas com operador não (!)

1

2

!(X < 12)

!(Y == 10)

A figura 5.5, ilustra uma situação cotidiana, do uso de operadores lógicos.

82

Programação I

Figura 5.5: Uso cotidiano de operadores lógicos

Nós também poderemos ter expressões lógicas, em que aparecem mais de um tipo de operadores lógicos, além de operadores aritméticos. Vejamos o exemplo 5.7.

Exemplo 5.7: Expressões Lógicas com vários operadores

1

2

3

4

(X > 10) && (Y < 30) || (Z == 1)

(A == 2) || (B <> C) && (D < 1) || (E > 10)

!(A == 1) || (B <= C + B)

(X + Y < Z + W) && (A < 3 + D) || (F < 5)

Nestes casos, vamos ver a tabela de prioridade de operadores, para a resolução de tais expressões.

Prioridade Operador

1º Operações embutidas em parênteses “mais internos”;

2º Resto e/ou multiplicação e/ou divisão;

3º Adição e/ou Subtração;

4º Operadores Relacionais;

5º Operadores Lógicos.

Primeiro, resolveremos as expressões aritméticas (seguindo a prioridade dos operadores aritméticos), depois as expressões relacionais e, finalmente, as expressões lógicas.

83

Programação I

5.2. Operadores Aritméticos de Atribuição

A linguagem C oferece um conjunto de operadores que é uma combinação de operador de atribuição e operador aritmético, são os operadores aritméticos de atribuição. Eles são utilizados para representar de maneira reduzida uma operação aritmética, seguida de uma atribuição. A próxima tabela apresenta os operadores aritméticos de atribuição e como utilizá-los em nossos programas.

Operador Exemplos de Uso Descrição

+= X += 4; Equivale a X = X + 4;

-= Y -= X; Equivale a Y = Y – X;

*= Z *= W; Equivale a Z = Z * W;

/= K /= 7; Equivale a K = K / 7;

%= L %= M; Equivale a L = L % M

Como pode ser visto, a sintaxe do operador aritmético de atribuição é: um operador aritmético(+, -, *, /, %) seguido do operador da atribuição (=). Uma expressão com este tipo de operador, significa que a variável do lado esquerdo da atribuição, além de receber o resultado, também fará parte da expressão aritmética. Vejamos o exemplo dado para o operador +=. A expressão X += 4, quer dizer que: será obtido o valor da variável X, adiciona 4, e este resultado é atribuído a própria variável X. Neste caso, é como se fosse um acumulador: acumule 4 ao valor que já tem na variável X.

5.3. Operadores ++ e --

Os operadores ++ e -- são utilizados após o nome de uma variável e servem para incrementar (++) ou decrementar (--) uma unidade da variável, ou seja, somar 1 ou subtrair 1 do valor da variável. A tabela abaixo apresenta os operadores ++ e --, seguidos de exemplos de uso. Após o ++ ou --, devemos colocar um ponto e vírgula.

Operador Exemplos de Uso Descrição

++ X++; Equivale a X = X + 1;

-- Y--; Equivale a Y = Y -- 1;

84

Programação I

No exemplo X++, significa que, se X=5, será somado 1 ao valor da variável X, e assim, X finalizará com 6. Da mesma forma, no exemplo Y--, significa que, se Y=5, será subtraído 1 do valor da variável Y, e assim, Y finalizará com 428.

5.4. Conversão de tipo

Quando usamos operadores aritméticos, temos que lembrar que o resultado da expressão depende do tipo das variáveis envolvidas. Por exemplo, quando dividimos dois números inteiros, o resultado é a parte inteira do quociente da divisão. Mas quando dividimos números reais, o resultado vem completo, a parte inteira e a parte fracionária do quociente. Outro detalhe que precisamos lembrar é que alguns operadores só podem ser usados por um tipo de dado. Este é o caso do operador do resto, nós só podemos utilizá-lo com dados do tipo inteiro.

Por conta disso, algumas vezes desejamos, momentaneamente, modificar o tipo do conteúdo de uma variável. Isto é, queremos que uma variável se “comporte” como se ela fosse de um tipo diferente do que ela foi declarada. Por exemplo: declaramos uma variável como int e queremos, momentaneamente, que seu conteúdo seja utilizado como um float. Este procedimento é chamado de conversão de tipo ou casting (moldagem, em Inglês).

A conversão de tipo é usada em uma expressão aritmética e é feita da seguinte forma: antes da variável, colocamos entre parênteses, o tipo que queremos que a variável seja nesta expressão aritmética. É importante salientar que a conversão de tipo é feita com o dado armazenado em uma variável, mas a variável continua tendo o seu tipo original. Vamos ver o exemplo 5.8, que apresenta uso de conversão de tipo.

Saiba Mais

28Os operadores ++, -- e operadores aritméticos de atribuição fazendo com que as nossas expressões fiquem menores, já que precisamos escrever menos coisas para a montagem da expressão.

85

Programação I

Exemplo 5.8: Conversão de tipo

1

2

3

4

5

6

7

int A,B,C;

float X,Y;

A=3;

B=5;

X=6.5;

C = (int)X % B;

Y = (float)A/B;

Nas linhas 1 e 2, temos as declarações de cinco variáveis. Nas linhas 3, 4, e 5 foram atribuídos valores as variáveis A, B e X. Na linha 6, precisamos executar uma operação para obter o resto da divisão entre a variável X (que é do tipo float) e a variável B (que é do tipo int). Esta operação não seria possível, já que o operador do resto não aceita números reais na expressão. No entanto, esta operação se torna possível, se fizermos a conversão de tipo da variável X. Queremos que, nesta expressão, o conteúdo de X seja um inteiro. Para isso, colocamos (int) na frente da variável X, como mostra a linha 6 do exemplo. Como a variável X tem 6.5 armazenado, nesta conta, a parte fracionária será desprezada e a conta será feita considerando que X é 6. Assim, 6 % 5 = 1. Então, 1 é o valor que será atribuído a variável C.

Vamos ver agora a atribuição da linha 7. Neste caso, estamos querendo fazer a divisão entre dois números inteiros. Esta conta é possível, mas ela traz como resultado, apenas a parte inteira do quociente. No entanto, há situações em que queremos dividir dois números inteiros, e receber o resultado completo, parte inteira e fracionária do quociente. Este é o caso da linha 7. Para que o resultado venha completo, basta que o conteúdo de uma das variáveis se comporte como um float. Com isso, um float dividido por um int, temos como resultado um float. Dessa forma, fizemos a conversão de tipo da variável A, solicitando que seu conteúdo se comporte como um float. Nesta linha 7 teremos, então, 3.0/5 = 0.6. Este é o valor que será atribuído a variável Y.

86

Programação I

5.5. Funções Matemáticas (biblioteca math.h)

A linguagem de programação C possui uma biblioteca que agrupa um conjunto de funções matemáticas. É a biblioteca math.h. Nesta seção, vamos ver quatro funções matemáticas, da biblioteca math.h, que utilizaremos com mais frequência nos nossos programas. São as funções para encontrar a raiz quadrada de um número, potência (elevar um número a uma potência) e duas funções de arredondamento. Esta biblioteca possui outras funções, mas estas são as mais utilizadas nos nossos programas.

As funções matemáticas precisam receber um ou vários parâmetros e nos retornam um resultado. Por exemplo, para descobrir a raiz quadrada de um número, a função precisa saber de que número será calculada a raiz quadrada. Este número que é fornecido à função é o parâmetro. Vamos ver a tabela a seguir, em que é feita a descrição destas funções.

Função Descrição Exemplos de uso

sqrt Função para encontrar a raiz quadrada de um número. A função sqrt precisa receber como parâmetro, o número que desejamos encontrar a sua raiz quadrada. O resultado desta função é um número real. Como uma função retorna um resultado, devemos atribuí-lo a uma variável.

R = sqrt(16);

R = sqrt(A);

pow Função para encontrar a potência de um número, ou seja, eleva um número a um expoente: AB. Assim, se A = 4 e B = 3, 4 elevado a 3 é 64. A função pow irá receber dois parâmetros. O primeiro é a base (neste exemplo é o A) e o segundo é o expoente (neste caso é o B). Esta função retorna um número real como resultado.

P = pow(3,4);

P = pow(A, 3);

ceil A função ceil serve para arredondar um número real. Esta função arredonda o número para cima. Assim, ela retornará como resultado: o primeiro número inteiro maior que o número que desejamos arredondar. Por exemplo: se x = 1.34, e desejamos arredondar com a função ceil, o resultado será 2.0. Ou seja, o primeiro número inteiro acima de 1.34. Apesar do arredondamento, esta função retorna um número real como resultado.

Z = ceil(1.67);

Z = ceil(Z);

87

Programação I

floor A função floor serve para arredondar um número real. Esta função arredonda o número para baixo. Assim, ela retornará como resultado: o primeiro número inteiro menor que o número que desejamos arredondar. Por exemplo: se x = 1.34, e desejamos arredondar com a função floor, o resultado será 1.0. Ou seja, o primeiro número inteiro abaixo de 1.34. Apesar do arredondamento, esta função retorna um número real como resultado.

Z = floor(1.67);

Z = floor(Z);

Atenção

Sempre que usarmos estas funções nos nossos programas, devemos incluir a biblioteca matemática, com a diretiva de compilação: #include <math.h>.

Devemos ficar atentos ao tipo de dado que a função retorna, para que seja feita a atribuição para uma variável compatível com o tipo do resultado. Por exemplo, não podemos atribuir o resultado da função pow, para uma variável inteira.

Programas Resolvidos

Nesta seção, vamos acompanhar a resolução de dois programas completos, que utilizarão os comando aprendidos neste capítulo. Vamos lá?

No primeiro programa que iremos analisar, o aluno fornecerá seu nome e as duas notas que tirou nas provas de programação. Como resultado, o programa vai imprimir a média do aluno. Segue abaixo o programa completo 5.1. Em seguida, vamos comentar cada linha.

88

Programação I

Programa Completo 5.1: Ler o nome e duas notas do usuário e imprimir a média.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include <stdio.h>

//ler o nome e as duas notas do aluno e imprimir a media

main()

{

char nome[20];

float nota1, nota2, media;

printf(“Calcular a media do aluno\n\n”);

printf(“Seu nome: “);

fflush(stdin);

gets(nome);

printf(“Nota 1: “);

scanf(“%f”, &nota1);

printf(“Nota 2: “);

scanf(“%f”, &nota2);

media = (nota1 + nota2)/2;

printf(“\n\n%s, sua media = %.2f”, nome, media);

getche();

}

Comentários sobre cada linha do Programa completo 5.1:

» Linha 1: Como iremos ler o nome do aluno, precisamos incluir a biblioteca stdio.h onde estão os comandos fflush e gets.

» Linha 2: Comentário informando o que o programa faz.

89

Programação I


» Linha 4: um abre chaves, que irá delimitar o corpo do programa principal.

» Linhas 5 e 6: declarações das quatro variáveis do programa: nome, nota1, nota2 e media.

» Linha 7: um printf que serve para colocar, no início da tela, o título do que o programa faz.

» Linha 8: printf para que o usuário saiba que precisa fornecer seu nome.

» Linha 9: comando fflush, que DEVE sempre vir antes do comando gets. Utilizado para limpar o buffer de entrada de dados.

» Linha 10: gets que efetuará a leitura do nome do usuário.

» Linha 11: printf para que o usuário saiba que precisa fornecer a primeira nota.

» Linha 12: scanf que lê a primeira nota e armazena na variável nota1.

» Linha 13: printf para que o usuário saiba que precisa fornecer a segunda nota.

» Linha 14: scanf que lê a segunda nota e armazena na variável nota2.

» Linha 15: cálculo da média do aluno. Notem que a soma das nota1 e nota2 aparece entre parênteses. Devemos lembrar que o operador da divisão tem prioridade maior que o operador da soma. Assim, para que a soma das notas seja feita primeiro, ela deve vir entre parênteses. Não esqueçam deste detalhe!

» Linha 16: printf que apresenta a média do aluno. Notem que na mensagem, também será escrito o nome do aluno. A média do aluno será apresentada com duas casas decimais (%.2f)

» Linha 17: comando getche que faz com que a tela de execução do programa fique aberta, e assim podemos ver o resultado do programa. Nesta linha também poderíamos usar o system(“pause”).

90

Programação I


É importante que vocês digitem estes programas resolvidos, no Dev-cpp, assim vão se familiarizando com a sintaxe do C, certo? Vamos fazer o outro programa?

Nosso segundo programa irá ler um número e vai imprimir a sua raiz quadrada. Segue abaixo o programa completo 5.2. Em seguida, vamos comentar cada linha.

Programa Completo 5.2: Ler um número e imprimir a raiz quadrada

1

2

3

4

5

6

7

8

9

10

11

12

#include <math.h>

//ler um número e encontrar a raiz quadrada

main()

{

float num, raiz;

printf(“Calcular a raiz quadrada de um numero\n\n”);

printf(“Numero: “);

scanf(“%f”, &num);

raiz = sqrt(num);

printf(“\n\nA raiz quadrada de %.1f = %.1f.”, num, raiz);

getche();

}

Comentários sobre cada linha do Programa completo 5.2:

» Linha 1: Para encontrar a raiz quadrada, iremos utilizar a função sqrt da biblioteca math.h. Assim, precisamos incluí-la no nosso programa.

» Linha 2: Comentário informando o que o programa faz.

91

Programação I


» Linha 4: um abre chaves, que irá delimitar o corpo do programa principal.

» Linha 5: as declarações das duas variáveis do programa: num e raiz.

» Linha 6: printf que serve para colocar, no início da tela, o título do que o programa faz.

» Linha 7: printf para que o usuário saiba que precisa fornecer o número.

» Linha 8: scanf que lê o número e armazena na variável num.

» Linha 9: cálculo da raiz quadrada do número. Usamos a função sqrt, passando como parâmetro o número que foi digitado pelo usuário (que está armazenado na variável num). O resultado da função sqrt é atribuído à variável raiz.

» Linha 10: printf que apresenta o resultado. Notem que será apresentada apenas uma casa decimal (%.1f) das variáveis num e raiz.

» Linha 11: comando getche que faz com que a tela de execução do programa fique aberta, e assim podemos ver o resultado do programa.


A figura 5.6 apresenta as duas telas de execução dos programas completos 5.1 e 5.2.

Figura 5.6: Telas de execução dos programas completos 5.1 e 5.2

92

Programação I

Com estes dois programas comentados, podemos dar início à resolução de mais uma lista de exercícios. Continuem programando!


Temos mais uma lista de exercícios para consolidar o entendimento do assunto visto neste capítulo. A maior parte das questões deve ser resolvida no computador, certo? Continuem fazendo os programas e sempre que der erro tenham calma para encontrá-los. Fiquem atentos(as) com a sintaxe de cada comando, para não cometer erros com tanta frequência. Vamos iniciar nosso novo treino?

1. Dados os valores inteiros abaixo:

MEDIA NOTA TOTAL Z K X I J A

0 2 10 0 7 4 80 -1 -4

Quais os valores resultantes depois da execução dos passos a seguir:

1) X = TOTAL/NOTA;

2) X = X+1;

3) NOTA = X;

4) TOTAL = NOTA + X + TOTAL;

5) MEDIA = 3;

6) K += 9;

7) Z = J / 5;

8) K = I % 5;

9) I ++;

10) I = I+2*A;

2. De acordo com os valores das variáveis abaixo, encontre o resultado das expressões lógicas com VERDADE ou FALSO:

A B C D E

10 3 2 2 25

a) A == D

b) (A>B) && (C==D)

c) (E+2<B+C) && (A==10)

93

Programação I

d) (D*E>100) || (B<5)

e) (E==25) && (A >B+C+D) && (C<B)

f) !(A < 15) && (B>=3)

g) (D>2) || (C == 7) && (E > 20)

3. Faça um programa que leia um número qualquer e imprima o seu cubo.

4. Uma empresa vai dar um aumento de salário ao seu funcionário. Faça um programa para ler o salário do funcionário e o percentual de reajuste. Calcular e escrever o valor do novo salário.

5. Faça um programa para ler o número de votos brancos, nulos e válidos de uma eleição. Calcular e escrever o percentual que cada um representa em relação ao total de eleitores.

6. Faça um programa que leia o número total de prestações de um consórcio, o total de prestações pagas e o valor atual da prestação. O programa deve calcular e apresentar o saldo devedor atual e a quantidade de prestações sem pagar.

7. Dada as seguintes entradas: quilometragem inicial, quilometragem final, litros consumidos, preço do litro de combustível. Faça um programa que imprima o seguinte Relatório: distância percorrida, Valor total gasto e o consumo do carro(quantos quilômetros percorre com 1 litro de combustível).

8. Um motorista de táxi deseja calcular o rendimento de seu carro na praça. Sabendo-se que o preço do combustível é de R$2.59, faça um programa para ler: a marcação do odômetro (Km) no início do dia, a marcação (Km) no final do dia, a quantidade de litros de combustível gasto e o valor total (R$) recebido dos passageiros. Calcular e escrever: a média do consumo em km/l e o lucro (líquido) do dia.

9. Faça um programa que leia os preços de uma mercadoria em abril e maio. Tendo como base a variação dos preços desta mercadoria, calcule a taxa de inflação.

10. Faça um programa que leia o tempo de duração de um evento em uma fábrica expressa em segundos e mostre-o expresso em horas, minutos e segundos.

94

Programação I

11. Faça um programa para um caixa eletrônico, que lê o valor que o cliente quer sacar e calcula o menor número possível de notas de 100,00, 50, 20 e 10 reais em que o valor lido pode ser decomposto. Escrever o valor do saque e a relação de notas necessárias. Suponha que o sistema monetário não utiliza centavos. Atenção: Só digite números múltiplos de 10.

Exemplo: Valor: R$ 380,00

Notas de R$ 100,00: 3

Notas de R$ 50,00: 1



Conheça Mais

Pesquisem na Internet outra funções matemáticas disponíveis na biblioteca math.h. Comecem a pesquisa pelo site:

http://visualcplus.blogspot.com/2006/03/mathh.html

Vamos revisar?

Para revisarmos os tópicos tratados neste capítulo, observem o resumo a seguir:

» Os operadores aritméticos são utilizados quando desejamos resolver expressões aritméticas. Devemos prestar atenção no tipo das variáveis que estão sendo utilizadas na expressão, pois o tipo interfere no resultado da expressão.

» Os operadores relacionais são utilizados quando desejamos comparar valores de variáveis. O resultado de uma expressão relacional é sempre “verdade” ou “falso”.

» Os operadores lógicos servem para interligar duas ou mais expressões relacionais. O resultado de uma expressão lógica é sempre “verdade” ou “falso”.

95

Programação I

» Podemos utilizar os operadores aritméticos de atribuição para reduzir o tamanho das expressões aritméticas.

» Os operadores ++ e – incrementam ou decrementam 1 de uma variável.

» Na biblioteca math.h podem ser encontradas funções matemáticas para encontrar a raiz quadrada de um número, potência, arredondamento de números reais, dentre outras.

Referências

ARAÚJO, Jairo. Dominando a Linguagem C. São Paulo: Ciência Moderna, 2004.

ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida Veneruchi. Fundamentos de Programação de Computadores. São Paulo: Prentice Hall, 2002.

DEITEL, H, M e DEITEL, P. J. Como Programar em C. Rio de Janeiro: LTC, 1999.

LAUREANO, Marcos. Programando em C Para Linux, Unix e Windows. Rio de Janeiro: Brasport, 2005.

MIZRAHI, Victorine Viviane. Treinamento em Linguagem C – Curso Completo. São Paulo: Makron, 1999.

MONTGOMERY, Eduard. Programando em C: Simples e Prático. São Paulo: Alta Books, 2006.

OLIVEIRA, Ulisses. Programando em C – Volume I – Fundamentos. São Paulo: Ciência Moderna, 2004.

SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 1996.

SEBESTA, Robert. Conceitos de Linguagem de Programação. São Paulo: Makron, 2003.

96

Programação I

Considerações Finais

Neste volume, tivemos a oportunidade de iniciar nosso aprendizado na linguagem de programação C. Nos capítulos 1 e 2, conhecemos os principais conceitos desta área (programação, linguagem de programação, um pouco do histórico do C, dentre outros), nos preparando para um melhor entendimento da linguagem de programação C. Nos capítulos 3, 4 e 5, começamos a estudar a sintaxe da linguagem de programação C, vimos os tipos de dados manipulados pela linguagem, os comandos de entrada e saída e a utilização dos operadores aritméticos, relacionais e lógicos. Estes assuntos nos deram o conhecimento suficiente para iniciar o desenvolvimento dos nossos primeiros programas em C. Mas estamos apenas no início. Temos mais três volumes, que nos darão a capacidade de desenvolver programas maiores. Continuem firmes nos estudos! Até o próximo módulo.

97

Programação I

Conhecendo a Autora

Sou graduada em Ciência da computação pela Universidade Federal de Sergipe. Fiz mestrado e doutorado na Universidade Federal de Pernambuco, desenvolvendo pesquisas nas áreas de Sistemas Distribuídos e Geoprocessamento. Começei a ensinar em 2000, nos cursos de Ciência da Computação e Sistemas de Informação. Desde o início da minha carreira como professora, ministro disciplinas de Programação e tenho uma paixão pela linguagem C. Atualmente, encontrei uma nova paixão: Educação a Distância.

Documents

Introdução a Programação C