Você está na página 1de 70

Introdução a Programação

em C e C++ for noobs.

Jonathas Lopes Moreira


Sumário
Introdução a Programação em C e C++ for noobs................................................................................ 1

Sumário .............................................................................................................................................. 2

Autor .................................................................................................................................................. 3

Prefácio .............................................................................................................................................. 4

Capitulo 1: Introdução ........................................................................................................................ 5

1.1 - O que é uma Linguagem de Programação................................................................................ 5

1.2 - Origem e diferenças do C e C++ ............................................................................................... 7

1.3 - Algoritmo ................................................................................................................................ 8

1. Exercícios rápidos de fixação: .................................................................................................... 13

Capitulo 2: Conceitos Iniciais ........................................................................................................... 14

2.1 - Configurando o local de trabalho .......................................................................................... 14

2.2 - Instalando o Notepad++ ........................................................................................................ 15

2.3 - Instalando o compilador ........................................................................................................ 19

2.4 - Configurando variável de ambiente: ...................................................................................... 23

2.5 - Olá Mundo ............................................................................................................................ 28

2.6 - Sequencias de escape............................................................................................................ 35

2.7 - Ola mundo em C++ ................................................................................................................ 38

2. Exercícios rápidos de fixação: .................................................................................................... 42

Capitulo 3: Iniciando a programação ................................................................................................. 44

3.1 - Palavras reservadas C e C++ .................................................................................................. 44

3.2 - Tipos primitivos ou fundamentais ......................................................................................... 47

3.3 - Variáveis ............................................................................................................................... 50

3.4 - Entrada e Saida ..................................................................................................................... 52

3.5 - Exemplos práticos ................................................................................................................. 62


Autor
Contato: fb.com/jonsistemas, jonprojetos@hotmail.com
Prefácio
Este livro foi elaborado com o objetivo principal de ser o mais completo texto possível
em relação ao conteúdo de programação e algoritmos em C e C++ para cursos introdutórios,
com esforço máximo para que ao mesmo tempo tenha uma boa didática, coisa que não
acontece com bastante livros atualmente, visto que quando possuem bom conteúdo, os
métodos e exemplos usados para passar ao leitor o conhecimento não são notáveis ou
suficientemente bons para uma melhor fixação do saber, por outro lado, se a didática é
notável, o conteúdo é simples demais.
Este livro-texto é aconselhado para ser usado como referência para disciplinas
introdutórias de computação ou programação em C e C++, mas também pode ser usado para
disciplinas posteriores, como as que envolvem o conceito de programação orientada a objetos,
(veremos adiante usando C++).
Capitulo 1: Introdução
1.1 - O que é uma Linguagem de Programação

Antes que saibamos o significado de uma linguagem de programação, devemos saber quem
ou o que utiliza essa linguagem, vamos rapidamente entender alguns conceitos básicos sobre
o nosso fiel amigo computador, que nada mais é do que uma grande¹ máquina de fazer
cálculos, que através de raciocínio lógico opera a uma velocidade absurdamente grande se
comparada ao dos humanos, porém não se preocupe, esse fato não o torna mais inteligente do
que uma pessoa, até então, nenhum possui a capacidade de raciocinar, isto é, perante uma
situação nova, ou a qual o computador não está programado, ele simplesmente irá ignorar esse
fato e esperará uma nova instrução ou comando.
Um computador também chamado de personal computer (pc) ou computador pessoal pode ser
dividido em duas partes:

 Hardware: São as partes físicas do computador, isto é, teclado, mouse, a placa de


vídeo, o processador, basicamente é tudo aquilo que você consegue tocar.

Figura 1.1-1

 Software: São as partes lógicas, os programas em forma geral, tal como um


programa editor de texto(Word), editor de planilhas, jogos, navegadores, sistemas
operacionais, etc.

Figura 1.1-2
Nesse livro, os programas são a nossa praia, a parte que nos interessa é a de software,
deixando o hardware para os engenheiros de computação e similares.

Obs¹: Na verdade, a tendência atual é que os computadores cada vez mais fiquem menores e mais potentes, ao
contrário dos primórdios da computação, onde os computadores enormes e pesados eram os que realizavam mais
cálculos.
Voltando então a linguagem de programação, pode-se afirmar que é uma forma de linguagem
a qual devemos aprender para conseguirmos nos comunicar com os computadores. A única
linguagem que eles entendem é a de máquina, que não é nada amigável aos humanos, pois é
totalmente baseada no sistema binário, onde sequências de 0 e 1 representam alguma
instrução ou tarefa à qual o CPU² deve administrar.

Figura 1.1-3
Não se desespere, não terá que aprender o sistema binário e digitar 0s e 1s para se comunicar
com o computador, atualmente poucas pessoas fazem isso, além de inviável, gasta-se muito
tempo e muitas linhas de instruções para se fazer poucas ações, é para evitar esse mal que
existem as linguagens de programação, onde você utilizará palavras especiais, em grande
maioria do inglês, para passar instruções a um programa especial³, que irá traduzir as suas
instruções para a linguagem binária a qual o computador entenderá.
De forma geral, ou informalmente, quando citamos linguagem de programação,
estamos nos referindo a uma linguagem de alto nível, porém há de se tomar cuidado pois
existem basicamente três níveis:

Figura 1.1-4
1. Alto nível: Linguagem mais próxima com o inglês do cotidiano, com menos números,
utilizando menos instruções para se fazer tarefas grandes (o código do exemplo conta
de 0 até 1 bilhão), porém é necessário um programa para traduzir o código digitado
para uma linguagem de baixo nível a qual o computador entenda, exemplos:
Linguagem C, C++, Java, Python, C#, Ocaml, etc.

2. Médio nível: É uma linguagem intermediaria, não é totalmente binária, mas necessita-se
digitar muito para fazer pouca coisa, o maior exemplo dessa linguagem é a linguagem de
montagem Assembly. Uma vantagem de se programar em nível mais baixo é que você pode
fazer com que seu código seja mais eficiente, e executará mais rápido, porem em tempos
atuais, com toda a potência dos computadores, os programadores³ acabam se preocupando
menos com os recursos usados pelo computador e focam-se mais no código que será escrito
em uma linguagem de alto nível.
3. Baixo nível: É a linguagem binária, ou linguagem natural do computador, a qual ele
entende diretamente sem necessitar tradução, cada computador entende somente a sua própria
linguagem de máquina a qual foi montado, é inviável para a maioria dos humanos escrever
programas em baixo nível, quem programa em baixo nível são os engenheiros de hardware
que trabalham na industrias de processadores.
Obs²: CPU (Central Processing Unit), é a unidade central de processamento, hardware responsável por
administrar todas as outras unidades do computador, controla por exemplo a ALU (Arithmetic and Logic Unit),
unidade de lógica e aritmética, que faz operações matemáticas, comparações, etc.
Obs³: Esse programa especial capaz de traduzir a linguagem de alto nível para a de baixo nível é chamado de
compilador.

1.2 - Origem e diferenças do C e C++


O C teve origem de duas linguagens BCPL e B, por volta de 1967 Martin Richards
criou a BCPL para ajudar a fazer um sistema operacional, mais tarde Ken Thompson criou a
linguagem B utilizando recursos da BCPL para ajudar a fazer o sistema operacional Unix em
seu laboratório na Bell em meados de 1970, a partir daí, Dennis Ritchie, também da Bell
Laboratories desenvolveu o C levando-se em conta a linguagem B, e a linguagem C é até hoje
uma das mais usadas na criação de sistemas operacionais, e programas que requerem alto
desempenho. Em 1990, levando-se em conta as enormes variações da linguagem, impedindo a
portabilidade de programas escritos em C de computador para computador, foi criado um
padrão chamado ANSI/ISO para consagrar o C de uma vez no mercado com uma alta
compatibilidade com outros sistemas computacionais.
“O C++ é um C com classe”, talvez você já tenha ouvido essa frase, na verdade, é
mais do que isso, é um novo paradigma, entenda paradigma como uma forma de abordar um
problema, uma nova visão, no paradigma do C, que é uma linguagem procedural, você trata o
seu problema de forma bruta, tudo o que possui são processos e dados, processos atuam sobre
dados para se alcançar um objetivo, basicamente você possui uma lista sequencial de ações a
se fazer, como se estivesse seguindo uma receita de bolo, ação por ação. O C++ surgiu por
volta de 1980 também na Bell Laboratories, primordialmente tudo que você consegue fazer
no C você conseguirá fazer no C++, além disso, você também encontra o paradigma da
orientação a objetos, isto é, você molda o seu problema baseando-se na realidade do seu
cotidiano, tudo o que você tenta descrever pode ser considerado um objeto, uma pessoa, um
despertador, uma venda, uma bicicleta, um cachorro, etc. Tente imaginar seu programa todo
composto por objetos, que trocam mensagens entre si, porem cada objeto determinado é
pertencente a uma classe, objetos da mesma classe possuem algo em comum, assim mesmo
como é na biologia, por exemplo, sabemos que todos os vertebrados possuem algo em comum
(provavelmente a coluna vertebral), se descermos mais um pouco na hierarquia, podemos
dizer que os mamíferos, que são uma especialização dos vertebrados, possuem ainda mais
coisas em comum, porém não deixando de ser um vertebrado, você acabou de visualizar um
dos conceitos mais importantes da POO (Programação Orientada a Objetos), o de herança,
conforme veremos alguns capítulos a frente.
Podemos resumir uma classe, como um conjunto de atributos e ações que um grupo de
objetos possuem em comum, por exemplo, o que pode-se dizer que é comum a todas as
bicicletas do mundo? Creio que todas elas (ou 99%) possuem um guidom, duas rodas, e dois
pedais (pelo menos as inteiras), e também possuem a capacidade de mover-se para frente,
consideramos a classe como esse molde da onde os objetos serão construídos, a diferença
entre classe e objeto é bem pequena, mas basicamente, objeto é quando se instancia ou se
declara uma classe, conforme veremos alguns capítulos a frente.
Fazendo uma síntese na diferença entre C e C++ levando-se em conta os dois
paradigmas (procedural e de orientação a objetos respectivamente), pode se afirmar que a
programação procedural:
 Tem como principal foco as ações (procedimentos e funções)
 Fornece melhor controle sobre o fluxo de execução de um programa, como exemplo
estruturas de sequências, decisão e repetição.
 São focadas em como um processo ou tarefa deve ser feita e não em o que deve ser
feito.
 Um dos problemas com a programação estruturada é que o seu programa não reflete o
mundo real com precisão.
E que a programação orientada a objetos:
 A ideia é modelar utilizando objetos, determinando como eles devem se comportar
e como devem interagir entre si.
 Surgiu da necessidade de modelar sistemas mais complexos.
 Separa-se a interface da implementação, isto é, um objeto A não consegue sabe
como um objeto B é internamente, mas pode conhecer o seu comportamento,
mapeando isso para um exemplo na vida real, você não precisa saber como
funciona o motor do carro para dirigi-lo, basta saber que se você pisar no
acelerador com o carro engrenado ele se locomoverá.
 Possui o conceito de relações entre objetos (associação, agregação, composição,
dependência, etc.), que indicam a forma a qual um objeto se relaciona com o outro.

1.3 - Algoritmo
É de suma importância entender o conceito de algoritmo, que é basicamente uma
sequência de passos bem definidos com um propósito específico e bem definido, por exemplo,
quais são os passos para se fritar um ovo?

Exemplo 1:
1) Ligar o fogão
2) Colocar uma frigideira na trempe
3) Colocar o óleo na frigideira
4) Quebrar o ovo e jogar na frigideira
5) Jogar sal e retirar após 2 minutos.

Figura 1.3-1
Uma outra versão de um algoritmo para fritar ovo pode ser:
Exemplo 2:
1) Coloque o ovo na frigideira e acenda o fogo
2) Jogue sal a gosto e aguarde 2 minutos

Observe que talvez você possua passos diferentes para se fritar um ovo, com mais ou menos
passos ou detalhes, mas o resultado final será sempre o mesmo, um ovo frito (ou queimado).
Esses exemplos apresentaram a forma narrativa de representação de algoritmo, existe
também a forma de pseudocódigo e a de fluxograma, confira alguns detalhes:
 Narrativa: Os algoritmos são apresentados em linguagem natural, citando-se os
passos conforme exemplos anteriores (1 e 2), uma desvantagem é que se escreve
muito para representar pouco.
 Fluxograma: Os algoritmos são representados usando-se formas geométricas para
demonstrar ações típicas de um programa:
Figura 1.3-2
Destes itens que montam um fluxograma, os mais importantes são o de [processo], [entrada e
saída de dados] e [decisão].
Processo: É tudo aquilo que for requisitar um cálculo, uma atribuição (quando se atribui um
valor a uma variável¹) ou declaração de variável.

Entrada e saída de dados: A entrada é quando o usuário interage com o programa, inserindo
um dado ou informação que será usada no programa, por exemplo, o usuário entra (insere ou
digita) com sua data de nascimento, já a saída diz respeito a informação que terá destino
algum dispositivo de saída (monitores, arquivos, impressoras, etc.), caso seja o monitor por
exemplo, pode ser exibido na tela a idade do usuário.
Decisão: Representa uma condição, por exemplo, verificar se uma variável x é maior que 10,
ou ainda, uma variável imc pode representar um dado de entrada que o usuário inseriu que
representa o seu IMC (Índice de Massa Corporal), logo através de uma decisão pode verificar
se um indivíduo está com peso ideal ou não, observe o exemplo seguinte:

Figura 1.3-3
Obs¹: Variável é onde se armazena valores que serão usados no programa, seja valores internos que você
armazena na hora da criação da variável, ou que o usuário irá inserir, podendo ou não sofrer alteração
posteriormente no programa.
Neste exemplo acima, o fluxograma busca mostrar se um aluno será aprovado ou não, dado
suas duas notas semestrais:
Começamos com o círculo representado o início.
Em seguida declaramos três variáveis, N1, N2 e M usando o retângulo que representa
processo, observe que é sempre uma boa pratica de programação declarar variáveis com
nomes sugestivos, nesse caso N1 e N2 representam a primeira e segunda nota do semestre, e
M é a variável onde será armazenado o valor da média das duas notas.
No próximo passo o usuário insere dois valores que são atribuídos para as variáveis N1 e N2
respectivamente, logo usa-se o trapézio que representa a entrada de dados.
Mais adiante o valor da média das duas notas é atribuído a variável M, usando-se mais uma
vez o retângulo.
Logo mais é feita uma condição usando o losango, que verifica se M que representa o valor da
média do aluno possui um valor maior ou igual a 6, se isso for verdadeiro, usaremos o
trapézio mais uma vez para escreveremos na tela do monitor por exemplo, “Aprovado”,
significando que o aluno foi aprovado, se M for menor que 6, fazendo com que a condição
seja falsa, logo será escrito na tela “Reprovado”, indicando que o aluno foi reprovado.
Finalmente é usado mais uma vez, o símbolo da elipse, representando o fim do fluxograma.
O fluxograma pode ser considerado um pouco melhor que a forma descritiva, facilita muito a
visualização do problema, porque além de ser mais conhecido, figuras dizem muito mais do
que palavras, porém ambos ficam complicados a medida que o algoritmo cresce.

 Pseudocódigo: Como o próprio nome já insinua, é um falso código, o que mais se


aproxima com um código de um algoritmo de uma linguagem de programação de
verdade, como C e C++, porém não possui aplicação na prática², basicamente se você
possuir o pseudocódigo de um algoritmo, a transferência para um linguagem de alto
nível será quase imediata, porém não é muito usado porque o tempo gasto fazendo-se
um pseudocódigo pode ser o mesmo de já implementa-lo em uma linguagem de alto
nível.
Obs²: Na verdade existem algumas pessoas que tentaram fazer um compilador para pseudocódigos, como o
Portugol, porém a linguagem é bastante limitada, com poucos recursos e bem menos conhecida.
Figura 1.3-4

Pode-se notar pelo exemplo, os mesmos conceitos do fluxograma, a declaração das variáveis
que serão usadas na linha 4 num1 e num2, o usuário interagindo com o sistema na linha 5
entrando com os valores de num1 e num2, e a verificação da condição para posterior
resposta.
Por motivos de pouca relevância, este livro não entrará com mais detalhes nesses três tipos de
representação de algoritmos, uma vez que não é esse o nosso foco principal, mas essa
abordagem inicial pode ser de grande ajuda para melhor compreensão do conteúdo dos
próximos capítulos.
1. Exercícios rápidos de fixação:
1) José estava fazendo uma transação bancária através da internet, porém algo deu
errado, seu navegador parou de funcionar repentinamente e a janela onde estava foi
finalizada, em um ato de fúria, arremessou a estrutura física do seu computador contra
a parede. A sequência de ações de José diz respeito respectivamente:
a) Hardware, software. b) Linguagem de alto nível, hardware
c) Software, hardware. d) Linguagem de alto nível, software

2) Marque a alternativa correta.


a) C++ é uma linguagem orientada a objetos de alto nível, enquanto que C é uma linguagem
procedural de baixo nível.
b) Linguagem de baixo nível é a linguagem que um computador entende naturalmente, sem
necessidade de tradução, as linguagens de alto nível surgiram devido ao fato de ser inviável
para os humanos programar em baixo nível.
c) No paradigma da programação orientada a objetos, abordamos o problema de forma
sequencial, porém uma cadeira é um exemplo de objeto, mas um cachorro não é.
d) No paradigma procedural, existe a ideia de relações, no orientado a objetos não existe esse
conceito.

3) Analise V (verdadeiro) ou F (Falso) para as afirmativas abaixo e marque a alternativa


correta.
( ) Das formas de representação de algoritmos, a única gráfica é a de pseudocódigo
( ) Uma das vantagens de algoritmos na forma descritiva ou narrada, é que qualquer pessoa
que entenda português consegue dizer qual a finalidade do mesmo.
( ) O uso de fluxogramas ajudam bastante na visualização, não existindo problema se o
algoritmo for grande demais.
( ) Se você já possuir um pseudocódigo pronto, é motivo de comemoração, pois transferir o
conceito para uma linguagem de alto nível é mais fácil, porém fazer um pseudocódigo para
depois transferir para uma linguagem de alto nível não é muito recomendado se o quesito
tempo for algo importante.
a) V V F V b) F V V V
c) F V V F d) F V F V
Capitulo 2: Conceitos Iniciais
2.1 - Configurando o local de trabalho
Antes de começarmos a programar, necessitamos ter nosso ambiente de
desenvolvimento, isto é, o nosso local de trabalho onde realmente iremos programar em C e
C++, não referindo-se é claro, ao local físico onde você permanecesse nesse momento, mas ao
local virtual de seu computador onde iremos preparar todas as ferramentas necessárias para
fazer nosso primeiro programa, para isso, devemos saber as fases a qual nosso programa irá
passar, algumas delas podem não fazer muito sentido ou conter palavras desconhecidas, mas
tudo será explicado com mais detalhes posteriormente, são elas:

 Digitar todo o código em um programa editor de texto e salvar o arquivo com devida
extensão¹ em disco.
 O programa pré-processador processará o código.
 O código-objeto² ou código de máquina será criado pelo compilador e armazenado em
disco.
 O linker vinculará o código-objeto com o código das funções gerando uma imagem
executável³.
 A imagem executável será carregada na memória principal ou memória RAM4 do
computador.
 Finalmente a CPU executará as instruções do programa.
Obs¹: A extensão de um arquivo é um sufixo dado a um nome de arquivo, que representa o formato de seu
arquivo, por exemplo, alguns arquivos de música possuem extensão .mp3, alguns de vídeo possuem extensão
.avi, um arquivo comum de texto (bloco de notas) do Windows possui extensão .txt.
Obs²: O código-objeto é o código que só o computador entende, que será usado posteriormente para criar o
código executável ou arquivo .exe
Obs³: O linker só tem papel porque os programas em C e C++ podem conter referências a dados definidos em
diferentes locais, deixando lacunas, cabe ao linker fazer a ligação de todas essas referências gerando assim uma
imagem executável do programa, sem lacunas.
Obs4: A memória RAM é o local onde ficam armazenados todos os processos e tarefas que serão executadas no
computador no momento, é extremamente rápida, porém ao se desligar o computador todos os dados que
estavam armazenados nela são perdidos.

Fazendo uma abstração bem grande dessas fases, o que necessitaremos na prática será um
editor de texto para escrever nossos códigos-fontes, e um compilador para compilar nossos
códigos fontes e gerar o tão desejável executável ou arquivo.exe (este que pode gerar outros
arquivos dependendo de sua aplicação).
É importante observar que existem programas chamados de IDE, ou ambiente de
desenvolvimento integrado, que é basicamente um programa que engloba todas as fases
descritas anteriormente. Abstraindo grosseiramente mais uma vez, pode se dizer que uma IDE
é um programa que possui um editor de texto, um compilador e um área de execução
embutida, existe uma variedade enorme de IDEs no mercado, algumas bem famosas e
gratuitas são: Code::Blocks, Eclipse e NetBeans.

2.2 - Instalando o Notepad++

Vamos começar usando um editor de texto e um compilador separadamente, para


posteriormente usarmos uma IDE, não faz sentido usar uma IDE se não entendermos como o
processo é realmente feito, logo usaremos o Notepad++ como editor de texto (http://notepad-
plus-plus.org/), basta ir até o site e clicar na guia download, e efetuar o download da versão
mais recente do Notepad++ (O link do download atual provavelmente estará no canto
esquerdo e com a tag “Current Version” ao seu lado).
Com o arquivo em mãos, de um duplo clique e prossiga a instalação, em seguida selecione a
linguagem:

Figura 2.2-1
Clique em “OK” e aparecerá a próxima janela:

Figura 2.2-2
Clique em “Próximo >” e aparecerá a próxima janela:

Figura 2.2-3
É interessante fazer a leitura de qualquer tipo de texto o qual você necessite clicar em “Eu
Concordo” para proseguir, logo é aconselhável a leitura (Por mais que poucas pessoas façam
isso).
Em seguida, aparecerá a próxima janela:

Figura 2.2-4
Selecione o diretório ou local de instalação para prosseguir e clique em “Próximo >”

Figura 2.2-5
Na nova janela, clique em “Próximo >” mais uma vez:

Figura 2.2-6
Por fim, se deseja que o ícone do Notepad++ esteja presente em sua área de trabalho deixe a
opção “Create Shortcut on Desktop” marcada e clique em “Instalar”:

Figura 2.2-7

Figura 2.2-8
Instalação concluida, clique em “Terminar”.

2.3 - Instalando o compilador

Partiremos para a instalação do nosso compilador C e C++, como nosso curso está voltado
para o sistema operacional da Microsoft Windows, a instalação será feita no mesmo, para isso
baixaremos o MinGW (Minimalist GNU for Windows) que nada mais é do que uma versão
portada para Microsoft Windows do conjunto de ferramentas GNU¹ , para isso vamos ao
site http://www.mingw.org/ e buscaremos o arquivo instalador, possivelmente estará no canto
superior direito da janela:

Figura 2.3-1
O leitor será direcionado para um outro site que começará a fazer o download do Installer, o
arquivo gerado será algo do tipo “mingw-get-setup.exe”.
Dê um duplo clique no arquivo baixado e aparecerá a janela:
Figura 2.3-2
Clique em “Install” e aparecerá a nova janela:

Figura 2.3-3
Escolha o diretório (não é muito aconselhavel mudar o diretório de instalação) e clique em
“Continue”, aparecerá a janela:
Figura 2.3-4
Aguarde um pouco o processo de instalação, em seguida a opção “Continue” será habilitada:

Figura 2.3-5
Cliquem em “Continue” e uma nova janela aparecerá:

Figura 2.3-6
Certifique-se de que todos os pacotes básicos ou todos os Package da guia “Basic Setup”
estejam instalados (na verdade para esse curso só usaremos os seguintes: mingw32-base e
mingw32-gcc-g++), caso não estejam instalados, marque-os e clique em “Installation” no
canto superior esquerdo e marque a opção “Aplly Changes”:
Estamos quase terminando a nossa configuração do nosso ambiente de trabalho, só falta agora
configurar as variáveis de ambiente², que é um processo que agilizará nosso trabalho.
Obs1: O conjunto de ferramentas GNU é um termo dado às ferramentas de programação produzidas pelo Projeto
GNU, que é um projeto lançado em 27 de setembro de 1983 por Richard Stallman. Na década de 1980, quase
todo o software era proprietário, o que significa que ele possuía donos, que proibiam e evitavam a cooperação
dos usuários. Foi desde então, que Projeto GNU foi necessário, possui como principal objetivo criar um sistema
operacional, chamado GNU, baseado em software livre. Estes projetos formam um sistema integrado que é
usado para desenvolver aplicações e sistemas operativos. Referência à http://pt.wikipedia.org/wiki/Projeto_GNU
adaptado.
Obs²: Variável de ambiente é uma variável de um sistema operacional que geralmente contém informações sobre
o sistema, caminhos de diretórios específicos no sistema de arquivos e as preferências do utilizador. Retirado de
http://pt.wikipedia.org/wiki/Variável_de_ambiente. (No nosso contexto, referenciaremos a variável de ambiente
“Path”, que estará mais relacionada a caminhos de diretórios conforme explicação acima ).

Para se ter uma noção sobre o quão importante é configurar a variável de ambiente, podemos
tomar exemplo da calculadora do Windows, existem diferentes formas de abrir a calculadora
do Windows, para versões do Windows 7 ou anteriores você pode abri-la através de:
 Iniciar > Programas > Acessórios > Calculadora
 Iniciar > Digitar “Calculadora” > Calculadora
 Iniciar > Digitar “cmd” > Prompt de Comando > Digitar “calc.exe”
 Meu Computador>Disco Local C>Windows>system32>calc.exe
Para Windows 8 ou 10:
 Ir na guia Pesquisar (conforme imagem) > Digitar “Calculadora” > Calculadora
 Ir na guia Pesquisar > Digitar “cmd” > Digitar “calc.exe”

 Meu Computador>Disco Local C>Windows>system32>calc.exe

Figura 2.3-7
Emfím, existem inúmeras maneiras, mas vamos prestar atenção nesta ultima do
Windows 8 ou 10:

• Ir na guia Pesquisar > Digitar “cmd” > Digitar “calc.exe”

Observe que todas estão se referindo ao mesmo arquivo, “calc.exe” que é o executável
responsável pela calculadora, porém nesta ultima, abrimos esse programa através do Prompt
de Comando do Windows (cmd), que é basicamente um interpretador de linha de comando no
qual podemos executar qualquer arquivo ou executável do computador (e onde executaremos
nosso compilador também).
Há de se notar que o trabalho após o cmd aberto foi somente digitar “calc.exe”, podemos
dizer que foi bem facilitado, isso porque, “calc.exe” ou nossa calculadora já está embutida na
variável de ambiente do nosso sistema, para qualquer outro arquivo do nosso computador que
não seja do sistema, devemos digitar o nome do diretório completo, por exemplo,
consideramos que temos um jogo instalado no computador chamado Age4.exe, e que não
temos o atalho dele na nossa área de trabalho, a única forma de executa-lo será ir até o local
onde está instalado, seja usando a interface gráfica (usando o mouse e navegando entre as
pastas) ou via cmd. Considerando usando o cmd, e que o local seja: “C:\Program Files
(x86)\Microsoft Games\Age of Empires 4\age4.exe”, basta escrever todo esse diretório no
cmd e pressionar enter que nosso jogo será aberto, mas isso é muito anti-prático e tedioso (é
por isso que existe os atalhos), se o nosso arquivo “age4.exe” estivesse na variável de
ambiente, o nosso trabalho seria somente digitar age4.exe após o cmd aberto, conforme
fizemos com calc.exe, com mais facilidade.

Talvez você esteja pensando: “Por qual motivo iria querer abrir algo pelo cmd se já criaram a
interface gráfica ou o mouse para esse motivo? ”. Acontece que os nossos compiladores de C
e C++ respectivamente (gcc.exe e g++.exe) que são arquivos situados na pasta
“C:\MinGW\bin\” não são abertos simplesmente clicando duas vezes sobre eles, uma vez que
os mesmos atuam obrigatoriamente sobre outros arquivos (os codigos-fontes e bibliotecas que
criamos), logo clicando duas vezes sobre eles não adiantaria nada, faltaria um parâmetro para
o compilador. É por isso que executar via cmd é essencial para nós, e que configurar a
variavel de ambiente é uma forma mais prática e eficiente para começarmos a programar.

2.4 - Configurando variável de ambiente:


Existem duas opções, na primeira basta abrir o Meu Computador, clique com o botão direito
em alguma area branca e clique em “Propriedades”:
Figura 2.4-1

Será aberta a seguinte janela:

Figura 2.4-2.
Obs: Pule os próximos dois passos se você ja visualiza a imagem acima.
A segunda opção é ir na guia “Pesquisar>Painel de Controle>Sistema e Segurança”:
Figura 2.4-3
Em seguida clique em “Sistema”:

Figura 2.4-4.
Obs: Clicando em Sistema você voltará para a imagem Figura 2.4-2 desse capítulo.
Após o passo descrito na Figura 2.4-2, clique em “Configurações avançadas do sistema”, e a
seguinte janela aparecerá:
Figura 2.4-5

Clique então em “Variáveis de Ambiente”, a seguinte janela aparecerá:

Figura 2.4-6
Na guia “Variáveis do sistema” (cuidado para não confundir com “Variáveis de
usuário...”), usando a barra de rolagem, busque pelo campo Path, selecione-o, e clique em
“Editar...” conforme imagem a seguir:

Figura 2.4-7
Em seguida, será aberto a seguinte janela:

Figura 2.4-8
Tomando muito cuidado para não apagar nada do que já está escrito, vá para o final do campo
“Valor da variável” e insira um ponto e vírgula no final ( ; ) , e também, insira o diretório
onde você escolheu para a instalação de seu MinGw, o padrão é C:\MinGw\bin, feito isso,
clique em “OK”, é altamente recomendável reiniciar o seu computador nesse momento.
Para testarmos se realmente nosso trabalho não foi em vão, basta abrirmos o cmd
(Pesquisar>cmd) e digitarmos gcc ou g++, para ambos os casos a resposta deverá ser
conforme demonstra a imagem seguinte:
Figura 2.4-9
Se aparecer algo do tipo:

Figura 2.4-10
Significa que algum passo deu errado, leia novamente o texto e refaça os passos.

2.5 - Olá Mundo


Estamos prontos para fazer nosso primeiro programa, primeiros vamos criar uma pasta
para salvar nossos exemplos, “C:\Exercicios” pode ser uma boa opção, como iremos fazer
programas em C e C++, foram criadas as pastas C e Cpp dentro da pasta Exercicios, conforme
a imagem abaixo:
Figura 2.5-1

Criaremos nosso primeiro programa em C, logo vamos abrir o editor de textos Notepad++ e
salvar um arquivo em branco com nome “olamundo” e extensão “.c“ clicando em “Tipo” e
selecionando “C source file”. É muito importante mudar a extensão para .c no fim, outra
opção é escolher o tipo “All types (*.*)” e colocar o nome do arquivo seguido de .c no fim:

Figura 2.5-2

Ou também:
Figura 2.5-3

O programa seguinte imprimirá na tela do computador a mensagem “Ola Mundo”, vamos


somente copiar tudo da imagem abaixo e colar no nosso arquivo olamundo.c e salvar, de
maneira alguma esqueça dos ponto e vírgulas ‘;”. Você pode salvar (apertando Control + S)
ou clicando em Arquivo>Salvar.

Obs: Se você tiver salvado o arquivo da maneira correta, perceberá que algumas linhas irão se colorir
automaticamente, ao contrário do que seria se usassemos um editor de texto comum como o bloco de notas
(notepad.exe) do Windows.

Figura 2.5-4 (olamundo.c)

Interpretando cada linha:

Na linha 1, temos o exemplo de um comentário em linha, tudo o que estiver depois das duas
barras “//” é considerado um comentário, o compilador ignora todas as linhas que são do tipo
de comentário, isto é, comentários tem função somente para os programadores se
identificarem com o programa, visto que programas grandes possuem trechos muito
complexos, e informações descritivas escritas na forma de comentários podem ser uma
excelente ajuda para o entendimento. Da linha 8 à linha 11 temos outro exemplo de
comentário, porem este pode se prolongar por mais de uma linha, tudo que estiver entre /* e */
será considerado um comentário para o compilador.

Linha 2, na grande maioria das vezes que se usar o #, indica que o pré-processador será
chamado, isto é, antes mesmo de se compilar o programa essa operação será feita, nesse caso
específico, o pré-processador inclui um cabeçalho (ou header) <stdio.h> da biblioteca padrão
do C, a libc, talvez o header mais famoso, responsável por comandos de entrada (usuário
inserindo dados) e saída (informação fluindo para algum dispositivo de saída ), uma biblioteca
é basicamente um conjunto de subprogramas utilizados no desenvolvimento de um programa,
esses subprogramas são chamados através do headers onde são declarados. A biblioteca
padrão ANSI C consiste de 24 cabeçalhos, cada um contendo uma ou mais declarações de
funções¹, tipos de dados² e macros³.

Obs¹: Veremos funções em um capítulo a parte, no exemplo, printf é um exemplo de função.

Obs²: Tipos de dados são os tipos que uma variável pode apresentar, por exemplo, uma variável que representa o
sexo de uma pessoa, será do tipo char, que representa uma letra, isto é, M ou F, já uma variável que representa
uma idade pode ser do tipo int, que representa um numero inteiro, podendo ser 25 ou 6808789 por exemplo.

Obs³: Macros em C funcionam na forma de substituição textual, em tempo de pré-processador, abordaremos


mais à frente com melhores exemplos.

Ainda com relação a linha 2, podemos afirmar que ela está diretamente ligada com a linha 5,
visto que a função printf é uma função definida no header <stdio.h>, em teoria, sem essa
função o programa daria erro de compilação, porém, com o avanço dos compiladores e
<stdio.h> ser uma biblioteca bem conhecida, alguns compiladores assim como o que estamos
usando, deixam esse erro passar, mas nos alerta sobre um perigo (warning) conforme veremos
logo mais.

Com relação a linha 3, temos a declaração da função main, que como o próprio nome diz, é
nossa função principal (main em tradução literal do inglês significa principal), nenhum
programa em C ou C++ existe sem a função main, é por ela que todo programa começa, e é
por ela que todo programa termina (pelo menos os sem bugs). O tipo int antes de main
significa que ela retorna um valor inteiro, mas seria uma falta de senso muito grande tentar
explicar o que são funções e tipo de retorno de funções nesse momento, por hora, basta você
estar ciente que a main é a principal função do seu programa, e só existe um main por
programa.

Na linha 4, temos a continuação da função main, o simbolo de chave aberta ‘{‘ significa onde
a função começa, ou melhor, onde o corpo da função começa, consequentemente, na linha 7,
o simbolo ‘}’ significa que a função terminou, ou seu corpo terminou, o código compreendido
entre a linha 4 e a linha 7 é chamagdfdo de bloco.

A linha 5 diz respeito a nossa função declarada no header <stdio.h>, printf é uma função que
retorna um inteiro representando o número de caracteres inseridos, e tem como principal
papel imprimir textos e valores de variáveis que são recebidos como parâmetro (dados que
ficam entre os parentesis), em nosso caso, printf imprimirá o texto “Ola Mundo” no cmd do
Windows sem as aspas.

Você pode verificar todas as funções que compoe algum header padrão do C ou C++, como o
header <stdio.h> em http://www.cplusplus.com/reference/, a <stdio.h> do C cumpre o
mesmo papel que a <cstdio> do C++.

A linha 6 , basicamente irá nos dizer que o programa terminou de maneira correta, deve ser
colocada sempre, em toda função main, mesmo porque, a ausencia do return fará com que
nosso compilador reclame ou nos alerte sobre alguma warning, a palavra chave (keyword)
return será usada frequentemente em funções que retornam algo.

É uma boa prática de programação identar o código, isto é, dar tabulações (apertar
tab) em tudo que estiver dentro de um bloco de código, de forma que fique mais a direita com
relação a linha anterior a chave aberta ‘{‘. Por exemplo, no corpo da nossa função main, todas
as linhas estão espaçadas ou com uma tabulação com relação a linha ‘int main()’.

Finalmente estamos prontos para compilar nosso primeiro programa, vamos abrir o cmd ou
Prompt de Comandos do Windows (Pesquisar>cmd).

Figura 2.5-5

Para compilarmos nosso programa, devemos navegar para a pasta onde está o nosso código
fonte (“C:Exercicios\C”), pois o Prompt de Comando sempre abrirá em nossa pasta do
usuário atualmente logado no Windows, nesse caso, a pasta do usuário atualmente logado é o
diretório “C:\Users\Jonathas”. Para navegarmos devemos conhecer alguns comandos básicos
do cmd:

 cd: É o comando responsável por navegar de uma pasta para outra, por exemplo, a
operação “cd C:\” sem as aspas, irá nos levar para o disco local C, não importando a
nossa localização atual, já o comando “cd ..” irá nos levar para o diretório um nível

acima do que estamos, se estivermos no diretório “C:\Users\Jonathas” e usarmos o


comando “cd ..”, também sem as aspas, automaticamente iremos para o diretório
“C:\Users”. Podemos também, escrever o diretório por completo de uma só vez,
como: “cd C:\Exercicios\C”, navegando assim para a pasta desejada. A forma mais
comum de usar o comando cd é pulando de pasta em pasta como se faz usando o
mouse, isto é, para chegarmos na pasta C:\Exercicios\C, entraremos com os seguintes
comandos: “cd C:\”, em seguida “cd Exercicios”, e por fim, “cd C”, todos sem aspas.

Obs: Se seu diretório possuir espaços, como exemplo a pasta “C:\Exercicios de programação”, é
necessário escrever o comando cd usando aspas no diretório, exatamente dessa forma: cd
“C:\Exercicios de programação”.

 dir: Lista todos os arquivos da pasta atual, na maioria das vezes que usarmos o
comando cd, pode ser seguido do comando dir, para sabermos qual será a próxima
pasta a ser navegada.

 cls: Limpa a tela do Prompt de Comando, caso você ache que ela esteja muito poluída
dificultando a visualização das informações.

Figura 2.5-6

Na figura 2.5-6 saímos da pasta C:\Users\Jonathas para C:\ com o comando cd C:\ .

Em seguida navegamos para a pasta seguinte C:\Exercicios, e usamos o comando dir para
listar tudo o que contem na pasta, podemos visualizar que a pasta atual onde estamos
contem duas outras pastas C e Cpp (que foi justamente as pastas que criamos
anteriormente). Tendo ciência da existencia da pasta C, navegamos para ela com o
comando cd C e usamos mais uma vez o comando dir para listar o conteúdo da pasta. Lá
está ele, nosso código-fonte olamundo.c, hora de o compilarmos:
Lembra do nome do nosso compilador C? O nosso amigo gcc, a grande maioria de nossas
compilações serão feitas da seguinte maneira (seja para C ou C++):

[nome do compilador] [nome codigo fonte] [-o] [nome executavel] [-Wall]

Usando então o gcc para nosso código fonte:

gcc olamundo.c -o ola -Wall

Obs¹: O -o serve para dar o nome do nosso programa para o próximo parametro, que no nosso caso será o
ola, gerando então o ola.exe, o -Wall serve para destacar todas as warnings (alertas) que nosso código
apresentar.

Obs²: Se omitirmos o -o e o ola, será criado um programa de nome a.exe

Limpando a tela com o cls e compilando então nosso arquivo fonte apertando enter:

Figura 2.5-7

Se nenhuma mensagem apareceu no momento que você apertou enter, parabéns, seu código
compilou com sucesso, e o arquivo ola.exe foi criado na mesma pasta, conforme mostra a
figura seguinte:

Figura 2.5-8

Nem tente clicar duas vezes no arquivo executável, pois ele abrirá e fechará no mesmo
momento, pois não inserimos nenhum comando para o programa continuar.

A forma certa de executar o programa é digitar o nome do seu executável no cmd:


Figura 2.5-9

Finalmente conforme mostra a figura anterior, nosso programa executou com sucesso
exibindo a mensagem “Ola Mundo”.

2.6 - Sequencias de escape


Sequências de escape são caracteres especiais que são inseridos nos fluxos de saída
(como a função printf por exemplo) e fazem uma ação peculiar, como pular linha, saltar
espaços, voltar para o inicio da linha, inserir caractere especial,etc. Vejamos os mais usados
deles:

\n Pula uma linha

\t Salta espaços (Tab)

\0 Finaliza a string

\b Volta uma posição atras no cursor

\r Volta para o início da linha

\a Emite um sinal sonoro

\\ Insire uma barra

\” Insere uma aspas

\' Insere um apóstrofo

Figura 2.6-1

A tabela completa pode ser encontrada na seguinte referência:


http://en.cppreference.com/w/cpp/language/escape

Vamos explorar esses caracteres especiais em nosso programa olamundo.c, ou melhor, vamos
salvar uma nova versão (olamundo2.c), onde pularemos a linha após o “Ola”.
Logo, salvando um novo arquivo com nome olamundo2.c (Control+Alt+S) na mesma pasta
(C:\Exercicios\C), vamos fazer essa simples alteração na versão anterior:

Figura 2.6-2 (olamundo2.c)

A figura acima imprimirá na nossa saída a seguinte mensagem:

Ola

Mundo

Se em vez do \n, fosse um \t, a saída seria:

Ola Mundo

Se \0, a saída seria somente:

Ola

Pois o \0 indica fim de string (string representa texto, veremos com mais detalhes à frente).

Figura 2.6-3 (olamundo3.c)


Na figura 2.6-3, foi adicionado um \n depois de Ola, um \t após cada letra de Mundo, e um
\a para emitir um bipe sonoro no fim.

A sairá será:

Ola

M u n d o

Observe o código a seguir, e tente decifrar a sua saída olhando para a tabela da figura 2.6-1
(reserve um tempo para pensar) :

Figura 2.6-3 (olamundo4.c)

Olhando em nossa tabela da figura Figura 2.6-1, podemos ver que o \r volta o cursor para o
inicio da linha, \b volta uma posição do cursor, e \0 finaliza o fluxo de saída, logo nossa saída
será:

Até a linha 4:

OlaMundo

Até a linha 5, Como temos a presença do \r, o cursor do mouse voltará a esquerda da letra
‘O’, e sobrescreverá “Ola” por Rai, ficando:

RaiMundo (e pulando uma linha)

Até a linha 6:

RaiMundo

esta bem (pula outra linha)

Até a linha 7, A mensagem “esta bem” se repete:


RaiMundo

esta bem

esta bem

Até a linha 8, Os três \b seguidos fará o cursor voltar três posições, sobrescrevendo o bem por
mal:

Raimundo

esta bem

esta mal

Até a linha 9: Usamos aqui uma nova função que a primeira vista possui a mesma
característica da printf(imprimir uma mensagem), mas veremos que a printf é muito mais
completa que a puts, porém a puts foi usado estrategicamente nessa ocasião, pois caso
usassemos a printf, o compilador (outros testados não geraram warnings) reclamaria de uma
possível warning por questões de segurança, tudo por causa do \0 nessa situação, como o \0
interrompe o fluxo de saída, a palavra “feijao” não irá aparecer, a saída será então:

Raimundo

esta bem

esta mal

não \gosta\ de “comer”

Observe a presença dos caracteres de escape para conseguirmos colocar na tela o caracter \ e
“.

2.7 - Ola mundo em C++


Programas feitos em C compilarão em C++(ao menos 99% deles), isto é, nós podemos
usar o compilador g++ para compilar os nossos programas feitos em C também, apesar de não
ser recomendável, porém o comando g++ olamundo.c -o ok -Wall funcionaria igualmente.

A imagem abaixo mostra nossa versão “olamundo.cpp” criado na pasta “C:\Exercicios\Cpp”:

Figura 2.7-1 (olamundo.cpp)


Similarmente ao nosso olamundo.c da figura 2.5-4, na linha 2, temos uma diretiva de pré-
processador que inclui o header de entrada e saída da biblioteca padrão do C++, a iostream,
observe que não devemos acrescentar o .h conforme fizemos com a <stdio>.

Obs: Podemos usar as bibliotecas do C em C++, porem elas perdem o .h e começam com c, por exemplo, a
<stdio.h> torna-se <cstdio>.

Na linha 5, podemos visualizar duas coisas novas, std:: e cout<<, vejamos elas:

“std” é nada mais nada menos do que um espaço de nomes (talvez o mais importante deles), é
em um espaço de nomes, onde estão definidos varias funções, classes, tipos e funcionalidades
que irão nos ajudar a criar nossos programas, basicamente, o comando std::cout indica que
queremos utilizar a função cout (que é similar a printf em C) do espaço de nomes std. “Ok,
mas quando irei utilizar isso”?. Primeiramente, um espaço de nomes serve para evitar colisões
de nomes iguais fazendo coisas diferentes, isto é, talvez em um espaço de nomes A voce
possua uma variavel x que tenha como valor 10, mas em um outro espaço de nomes B, voce
tenha uma variavel com o mesmo nome x, mas que possua valor 20, qual delas o compilador
utilizará? É por isso que temos que especificar qual o espaço de nomes iremos utilizar, no
nosso caso, utilizamos o std que possui a função cout declarada em seu escopo.

Para melhor entendimento, vamos fazer uma nova versão do nosso programa olamundo em
C++, com uma adaptação prática:

Figura 2.7-2 (olamundo2.cpp)

Observe que na linha 3, estamos de forma explícita, indicando para o compilador que
queremos usar o espaço de nomes std(com a palavra using, dessa forma, não precisamos mais
fazer uma declaração do tipo:

“std::cout<<”Ola\nMundo”;

Simplesmente:

“cout<<”Ola\nMundo”; conforme demonstrado na linha 6.

Pois o compilador agora reconhece que todo nome “cout” está se referindo ao “cout” do
espaço de nomes std, que corresponde a função desejada de imprimir algo na tela.
O restante do conteúdo dessa seção 2.7 (com exceção dos exercicios de fixação)
explicando sobre espaço de nomes não é muito relevante para a parte inicial do curso, você
pode pular para o capitulo 3 e ler mais tarde se desejar.

Podemos criar nossos espaços de nomes, simplesmente digitando a palavra chave


namespace seguida do nome do espaço de nomes, vamos apresentar alem de exemplos de
espaço de nome, um tipo primitivo tanto da linguagem C quanto de C++, o int, que é o tipo
responsavel por representar variáveis que irão armazenar valores inteiros( 1, -3, 45, -50, etc),
e também a função endl:

Figura 2.7-3 (olamundo3.cpp)

Da linha 7 a linha 11 declaramos um espaço de nome chamado idade, da linha 12 a


linha 16 declaramos outro espaço de nome chamado dias, todos dois possuem duas variáveis
do tipo int (consequentemente armazenam valores inteiros), e possuem o mesmo nome (para x
e para y), porem valores diferentes são atribuido a elas, na linha 14 por exemplo, estamos
atribuindo o valor 7 para a variavel x, ao contrario da linha 9 na qual x recebe 22.

Na linha 19 é apresentado a função endl, que possui a mesma função do \n (pular uma linha),
a pequena diferença é que ele também limpa o buffer (será explicado mais tarde), na prática
acabam fazendo a mesma função. Essa linha é equivalente à:

cout <<”Ola”<<endl<<”Mundo”<<endl;
ou também:

cout <<”Ola”\nMundo\n”;

Na linha 20, pela primeira vez, estamos utilizando um fluxo de saída para imprimir o valor de
uma variável, nesse caso o valor de x do espaço de nome idade, já na linha 21, imprimimos o
valor de x presente no espaço dias.

Na linha 24 usamos todos os nomes do espaço dias, logo da proxima vez que quisermos
imprimir tanto x quanto y, não precisamos mais especificar qual espaço ambos pertencem.
Conforme é feito na linha 25, onde também de forma inédita, imprimos o valor de um texto e
de uma variavel em uma só instrução ou linha de código, sempre usando o operador “<< “
para delimitar cada instrução, talvez você note um erro de portugues nessa mesma linha,
acontece é que o “eh” no lugar de “é” foi proposital, uma vez que acentos, certos tipos de
pontuações e letras (como ç), não aparecem perfeitamente quando se manda imprimir na tela,
pelo menos não no modo padrão, devido que a linguagem padrão da maioria dos
compiladores é a inglesa, a qual não possui esses tipos de caracteres, porem nada que não
possa ser configurado a nosso gosto posteriormente.

Na linha 27, redefinimos qual espaço de nome devemos ler nossa variavel x, agora ela não
mais, deve ser lida de dias, mas sim de idade. As linhas 29 e 30 são desnecessárias, uma vez
que o y já estava sendo usado de dias.

Na linha 31, também ineditamente, redefinimos ou alteramos o valor de uma variável, nesse
caso a variável y de dias, que antes possuia o valor 14, agora passa a valer 999 conforme
mostrado na linha 32.

A linha 33 nos mostra que mesmo usando o y do espaço dias, não perdemos o valor de y do
espaço idade, imprimindo o na tela.

Analise a saída do nosso programa (olamundo3.cpp):


Figura 2.7-4

A partir de agora, em todos nossos programas C++, por questões de praticidade, usaremos o
espaço de nomes std:

using namespace std;

2. Exercícios rápidos de fixação:


1) Faça um programa que imprima seu nome completo utilizando a função printf,
saltando uma linha para cada nome, e gere um executável nomeado meunome.exe.
Exemplo de saída:
Joao
Lopes
Silva

Com relação a imagem a seguir, responda as questões 2 e 3.

Figura 2.7-5

2) Elabore um código que gere o triangulo de asteriscos da imagem.

3) O comando gcc 2-exer2Triangulo.c –o triangulo –Wall está relacionado a compilação


ou a execução do programa? Substitua gcc por g++ e comente o que foi observado.

4) Identifique se existir, o(s) erro(s) dos códigos a seguir:


Figura 2.7-6

Figura 2.7-7

Figura 2.7-8

5) Marque V(verdadeiro) ou F(falso) para as afirmações a seguir:

( ) – Não é necessário utilizar std::cout todas as vezes que se quiser utilizar a função cout,
para isto basta declarar using namespace std, e usar simplesmente cout.

( ) – #include <stdio.h> e #include <iostream> são cabeçalhos que controlam funções de


entrada e saida do C e do C++ respectivamente.

( ) – O comando: g++ meuPrograma -o arquivo.cpp –Wall compilará um arquivo chamado


arquivo.cpp e gerará um executavel meuPrograma.exe

( ) – Tanto \n quanto endl saltam uma linha, porem o \n somente funciona na linguagem C, e
o endl somente funciona na linguagem C++.

( ) – Omitir a linha return 0 não gera um erro de compilação, embora seja altamente
recomendável não omiti-la.
Capitulo 3: Iniciando a Programação
3.1 - Palavras reservadas C e C++
As palavras reservadas são o nosso vocabulário para “conversarmos” com o
compilador através das linguagens de programação, o mesma envia nossas instruções
traduzidas na forma que o computador entenderá.

É um erro tentar usar palavras reservadas como nome de variáveis ou algo


relacionado, por isso é bom ter uma noção dos nomes que se pode usar:

Keywords ou palavras reservadas da linguagem C:

Figura 3.1-1

Figura 3.1-2
Figura 3.1-3

Figura 3.1-4

http://en.cppreference.com/w/c/keyword

As ultimas atualizações estão com um (since C99) significando que foram inseridas
desde esse acordo de 1999, c99 é um nome informal para ISO/IEC 9899:1999 quando
profissionais da area da computação se reuniram para estabelecer certos padrões da
linguagem e adicionando alguns recursos, observe que houve uma outra reunião nesse
mesmo estilo em 2011, gerando o padrão C11 ( ISO/IEC 9899:2011). Nesse ultimo uma
das principais mudanças foi o suporte a threads¹.

Obs¹: Uma thread permite que o usuário de um programa utilize uma funcionalidade do ambiente enquanto
outras linhas de execução realizam outros cálculos e operações.
https://pt.wikipedia.org/wiki/Thread_(ciência_da_computação)

Obs²: Podemos compilar nossos programas escolhendo qual padrão C ou C++ iremos utilizar, basta acrescentar
por exemplo –std=c99 ou std=c++11 na fase da compilação, por exemplo:

Compilando um arquivo no padrao C++11: g++ -std=c++11 arquivo.cpp -o tipos –Wall

Compilando um arquivo no padrao C99: gcc -std=c99 tarquivo.c -o tipos –Wall

Obs³: As keywords que mais usaremos estão na primeira figura (Figura 3.1-2), mais precisamente as três
primeiras colunas.

Obs4: A keyword pragma é usada para dar informação adicional ao compilador, é bastante usada quando se
trabalha com sistemas embutidos ou embarcados, quando se há necessidade de configurar o compilador para
fazer coisas mais específicas, desabilitar warnings, etc.
Keywords ou palavras reservadas da linguagem
C++:

Figura 3.1-5

Figura 3.1-6

http://en.cppreference.com/w/cpp/keyword

De forma análoga a C99 do C, (since C++11) significam as ultimas atualizações da


linguagem.

Obs: Os nomes da figura 3.1-6 são na verdade identificadores (podem ser usado como nomes de variáveis), que
ao serems usados junto de funções ou objetos possuem um significado especial.
3.2 - Tipos primitivos ou fundamentais
São tipos de dados que servem para declarar qual tipo de valor uma variavel pode
armazenar, vimos na seção 2.7 funções para manipular o fluxo de saida, agora vamos
trabalhar com a entrada, basicamente existem seis tipos primitivos:

 Caracteres: Tipos que armazenam uma letra ou um dígito, exemplo:

char letra;

 Inteiros: Tipos que armazenam valores inteiros, exemplo:

int numero = 2147483647;

Obs: No comando acima, diferentemente do anterior, além de declaramos o


tipo da variável numero como sendo do tipo inteiro (int), a inicializamos com
um determinado valor, que propositalmente é o maior inteiro (2^16 - 1) que se
pode representar com o tipo int para a maioria dos processadores.

 Ponto flutuante: Tipos que armazenam valores bem maiores que o do tipo
inteiro e ainda podem ser valores quebrados, por exemplo:

float altura = 1.82;

 Ponto flutuante de dupla precisão: O mesmo que o float porem com


capacidade para armazenar valores extremamente grandes.

double distancia = 1.7E+308

 Booleanos: Tipo que retorna verdadeiro ou falso, só é valido para C++, C não
apresenta esse tipo, por exemplo:

bool podeVotar = true;

 Vazio: Tipos especiais como null (mais usados com variáveis que
representaram ponteiros) e void (mais usado em funções).

Esses tipos primitivos podem vir mesclados com outros comandos para
modificar o tipo trazendo algum tipo de benefício, por exemplo, considerando
que os inteiros vao de -2147483647 até 2147483647, podemos considerar so os
inteiros positivos, acrescentando um unsigned antes do int, ignorando os
numeros negativos e aumentando o nosso range(alcance) de
0 para 4,294,967,295.

Obs: O que acontece na verdade é que o seu processador internamente deixa de utilizar o
primeiro bit que armazena o sinal do número, e passa a utiliza-lo para guardar outro número,
como o sistema de numeração é binário, o número dobra de valor, se por ventura fosse
decimal, uma ignorada de sinal equivaleria a poder guardar um número dez vezes maior na
memória.
Confira abaixo uma tabela com informações mais precisa sobre tipos:

Figura 3.2-1

http://en.cppreference.com/w/cpp/language/types

Basicamente short considera numeros menores, unsigned considera somente números sem
sinal(aumentando o alcance, podendo-se declarar numeros maiores), long aumenta mais o
alcance, e signed é o padrão, que significa numero com sinal, deixar de escrever signed ou
escrever não faz diferença.

Confira abaixo uma outra tabela que leva em conta o alcance dos tipos, observe que mesmo
por exemplo, declarando-se um unsigned int o valor pode variar dependendo do processador,
caso seja 16, 32, ou 64 bits:

Obs: Por mais que o tipo double consiga armazenar valores extremamente grandes, ou o tipo long double,
existem bibliotecas especiais caso necessite numeros superiores a 10308 por exemplo.
Figura 3.2-2

http://en.cppreference.com/w/cpp/language/types

Nossos programas começarão a ficar mais interessantes, com o uso do fluxo de entrada e
variáveis, ganhamos instantaneamente a possibilidade da interação com o usuário, na qual os
programas terão certa saída ou resposta de acordo com os dados inseridos pelo usuário.

Figura 3.3-3
3.3 - Variáveis
Uma definição mais formal de variável é uma posição de memória que pode ser identificada
através de um nome e podemos atribuir ou alterar seu valor, além disso, cada variável possui
um tipo, para usarmos as variáveis em C ou C++, primeiro temos que declara-las, isto é,
definirmos o seu tipo, e o seu identificador (nome), vale a pena ressaltar que existe um certo
padrão para nome de variáveis, e também existe o case-sensitive, isto é, uma variável de
nome area é difente de Area, que por sua vez é diferente de AREA, o padrão é dar nome a
suas variáveis de acordo com o que ela significa para o programa, por exemplo, se deseja
fazer um programa para verificar se determinada pessoa é maior de idade, criar uma variavel
de nome idade para representar a idade facilitaria no desenvolvimento do código.

O padrão para criar variáveis é o seguinte:

Figura 3.3-1

Obs: Em “double pi = 3.1419” a variável alem de declarada, foi também inicializada com determinado valor.

Se houver mais de uma variável do mesmo tipo, basta colocar os nomes na mesma linha,
seguido por virgulas, por exemplo:

float nota1, nota2, nota3;

string nome, sobrenome;

Quase qualquer tipo de nome pode ser dado para sua variável, com exceção das
keywords(palavras reservadas da linguagem), ou nomes começando com números ou
caracteres como: ?, %, #, @, etc. O caractere _ é permitido, isto é, pode-se criar uma variavel
do tipo:

int _idade;

Por convenção, todas nossas variáveis começarão sempre em minúsculas, e se possível


terminarão com somente letras minúsculas, com exceção da presença de palavras com nomes
compostos, visto que acrescentaremos a primeira letra maiúscula para as demais palavras, por
exemplo:

string primeiroNome, segundoNome;

float numeroDePessoas;
A primeira vista pode aparentar um pouco estranho, mas podemos requisitar que uma
variável nunca mude de valor, basicamente existem duas formas:

 Usando a diretiva de pré-processador #define, que permite substituir todas as


ocorrências da palavra à direita de #define, por valores a direita dessa palavra,
por exemplo:

#define PI 3.14159265;

#define TAM 100

Uma grande vantagem de fazer dessa maneira, é que ao invés de escrever um


numero muito extenso todas as vezes que for usalo, digitamos apenas a palavra
que o representa.

Obs¹: É um padrão usar sempre letras maíusculas para o nome utilizado em define

Obs²: Na verdade a variável usada em #define não é realmente chamada de variável, e sim de
macro, o que #define faz realmente é instruir a trocar todas as ocorrências com a macro
definida.

 Usando const antes do tipo em sua declaração, por exemplo:

const int idade = 18;

const float temperaturaMax = 38;

Obs¹: Usando const, um espaço será alocado para essa variável no sistema, ao contrário de
#define.

Obs²: Não vimos alteração de valor de variáveis ainda, mas tentar alterar o valor de uma
variável constante causará um erro na hora da compilação.

Para alterar o valor de uma variável é bem simples, basta escrever o nome da variável
e o valor correspondente:

idade = 30;

altura = 23.5;

sexo = ‘m’;

É possivel alterar o valor de uma variável não constante quantas vezes desejar, só não se
esqueça de certificar que ela foi devidamente declarada anteriormente.

Esteja sempre atento sobre qual valor uma variavel pode receber, um erro bem grotesco seria
tentar atribuir um texto ou string para uma variavel do tipo inteiro, um exemplo do que NÃO
se deve fazer:

int numeroCasa = 370;

numeroCasa = “370”;
3.4 - Entrada e Saida
Na parte final do capitulo 2, vimos um pouco sobre fluxos de saida, com as funções
printf, puts e cout, aperfeiçoaremos nossos conhecimentos sobre essas funções além de
estudar algumas novas de entrada, estas ultimas que possibilitarão a interação com o usuário.

Dispositivos de entrada são basicamente os dispositivos de onde a informação


consegue chegar no computador, onde o usuário consegue se comunicar com o usuário, o que
inclui teclado, mouse, joysticks, scanner, etc. O principal dispositivo que usaremos nesse
curso será o teclado, até mesmo porque é o padrão para o C e C++ em suas funções mais
comuns, de certo ponto de vista, até mesmo arquivos de texto armazenados no disco rígido
podem servir como arquivo de entrada para nossos programas.

Figura 3.4-1

Dispositivos de saida ao contrário dos de entrada, a informação vai do computador


para o exterior, transmitem dados e informações processadas pelo computador permitindo a
comunicação no sentido do computador para o utilizador, incluindo monitor, impressora,
placa-de-video, caixas de som, projetor, etc. O principal dispositivo que usaremos nesse curso
será o nosso monitor, até mesmo ja o utilizamos com as função que imprimiram texto na tela.

Figura 3.4-2
A forma mais simples de se ler uma entrada utilizando-se C é usando a função scanf,
porém ao contrário da similar a ela no C++ (cin), é necessário especificar qual o tipo da
variável que se está lendo no momento, varia se for int, double, float, char, etc. O mesmo se
aplica para a função printf.

Observe um exemplo da utilização da scanf no código abaixo:

Figura 3.4-3

Na linha 7, pela primeira vez estamos utilizando um vetor de um tipo primitivo, vetor
é basicamente uma coleção de variáveis armazenadas consecutivamente na memória,
falaremos sobre vetores mais tarde, por hora, basta saber que char nome[50] é uma variavel
que consegue armazenar uma cadeia de até 50 caracteres(na verdade 49, pois o ultimo
caractere sempre será o \0, que é uma espécie de sinal para indicar que a cadeia chegou ao
fim).

Chegando na linha 8, mais uma vez utilizamos a função puts para imprimir um texto na tela,
e observamos também o comentário do programador, que deixou um alerta explicando que
esta função salta uma linha automaticamente no seu fim.

Uma novidade está na linha 9, ineditamente utizamos nossa primeira função para entrada de
dados, a scanf, que simplesmente faz uma leitura da palavra digita através do teclado e copia
para o conteudo da variavel nome, utilizaremos a função scanf da seguinte maneira:

scanf( “%[QuantidadeMaximaDeCaracteresLidos] [EspecificadorDeConversao]”, &variavel);

Há de se notar que a quantidade maxima de caracteres lidos pode ser omitida, assim como o
& da variavel, no exemplo dado nossa variável não possui o &, pois é uma das nossas poucas
exceções, quando se lê um vetor de caracteres de uma só vez utilizando o %s, ele nao é
necessário, mas será um erro tem tempo de execução para qualquer um dos outros tipos
primitivos fundamentais o esquecimento do &.

Obs: É um erro bastante comum para iniciantes esquecer-se do & na leitura de dados, o que gera erro em tempo
de execução.

Observe na tabela abaixo os especificadores de conversão para cada tipo primitivo, a primeira
vista pode aparentar complicado mas não é, basta ter um pouco de prática e até mesmo
intuição para usa-los, a tabela está em ingles mas não é necessário um ingles tão aprofudando
para perceber os pontos principais, o que nos interessa mesmo é so a primeira coluna e a
segunda, que falam exatamente sobre o especificador e para qual tipo utilizar, confira:

Figura 3.4-4

http://www.cplusplus.com/reference/cstdio/scanf/

De inicio, vamos utilizar basicamente:

Figura 3.4-5

Isto é, se nosso numero é do tipo int, vamos usar o especificador de formato %d, se for float
%f, se for double %lf, e assim por diante.
Aproveitando o embalo da scanf, vamos analisar melhor a printf, que usa o mesmo
mecanismo de especificador de conversão para imprimir algo no meio do fluxo de saida.
Lembrar-se das tabela do scanf e do printf ao mesmo tempo não é necessário, pois
basicamente sabendo-se a do printf, automaticamente entende-se a do scanf, e vice-versa.

Confira a tabela abaixo de especificação de formato do printf:

Figura 3.4-6

http://www.cplusplus.com/reference/cstdio/printf/

Finalizando então a linha 9, passamos para a linha 10, que é so mais uma linha onde o
printf possui a mesma funçao do puts, porem sem saltar a linha.

Checando a linha 11 estamos imprimindo na tela do monitor o conteudo da variável nome,


que foi lida na linha 9 com o scanf, observe que poderiamos ter substituido a linha 10 e linha
11 por uma única linha:

Isto é, imprimimos um texto, e no local do %s, o compilador substitui pelo conteudo da


variável nome.

Observe uma segunda versão do programa mais aprimorada onde vamos ler além do nome,
também a idade da pessoa e imprimir junto com seu nome:
Figura 3.4-7

Compilação e execução do ultimo exemplo:

Figura 3.4-8

Relembrando, teste.c é o nome do nosso arquivo com o codigo em C, ok.exe é o nosso


arquivo de execução gerado.

Como entrada foram digitados o nome Jonathas e a idade 22, não fará diferença para o usuario
se ele digitar o nome e der um enter, para depois digitar a idade, ou se digitar o nome, saltar
um espaço e depois digitar a idade, conforme o exemplo de execução demonstra.

O problema que se pode ter, é o usuario digitar seu nome no lugar da idade, logo a variável do
tipo int teria que suportar uma variavel do tipo vetor de caracteres, causando erro em tempo
de execução. Logo sempre observe a ordem dos especificadores de tipo que coloca no seu
printf ou scanf, pois é de fundamental importancia.

Invertendo-se propositalmente a ordem, vamos observar o erro gerado pelo compilador:

Figura 3.4-9
Resultado da Compilação:

Figura 3.4-10

Pela primeira vez vemos o parâmetro –Wall em serviço, por felicidade ainda em tempo de
compilação conseguimos detectar o nosso erro.

Se mesmo assim tivessemos a intenção de compilar assumindo os possiveis riscos, observe o


resultado da execução:

Figura 3.4-11

Com certeza essa não era a saida inicialmente requisitada, mas é melhor conhecer os erros e
evita-los do que nem mesmo conhece-los.

Vejamos um mini-resumo de tudo que vimos até então:


Figura 3.4-12

Possiveis erros de iniciantes é colocar o & no printf, errar a ordem dos especificadores de
conversão, e o famoso esquecimento de algum ponto e virgula.

Exemplo de saída para o código supracitado:

Figura 3.4-13

Com relação a saida a cima, se voce estiver observado direito, na impressão do numero real
gigante veio dois 0s a mais, de fato não altera o valor, mas e se quisessemos especificar a
precisão? Por exemplo, somente duas casas decimais depois do ponto, ou 10 casas decimais, a
resposta está na nossa propria função printf, o que faz ela ser superior a função puts.

Vejamos um exemplo para explicação:


Figura 3.4-14

Agora compare sua saída:

Figura 3.4-15

O mais comum é utilizar o que está na linha 11, onde se controla somente a quantidade de
casas decimais, utilizando o %.3f, se fossem 10 casas decimais seria %.10f, creio que o
código caminhou gradualmente e não possua muito segredos.

Até fazer esse texto, confesso que não tinha conhecimento do que está na linha 14, achei bem
interessante poder especificar a quantidade de brancos atraves de um número que esta em
outro parâmetro da função, isto é, do lado direito da virgula que separa o texto e os
especificadores de formato do restantes, um 0 do lado esquerdo do * faria com que os espaços
em brancos ficassem preenchidos com 0 como nas linhas anteriores.

É notavel que a quantidade de espaços ou a quantidade de zeros que precedem a impressão de


algum número na tela não é exatamente o numero colocado entre o % e o especificador de
formato, por exemplo na linha 6, a especificação foi %020d, mas caso pare para contar,
perceberá que o número de zeros é exatamente:

[20 subtraido da quantidade de digitos do numero que será mostrado, no caso 1993]

Isso nos gera um resultado de 16, que é justamente a quantidade de zeros mostrada na tela.

Particularmente creio que seja mais facil imprimir números com certas quantidades de casas
decimais usando funções advindas do C( printf por exemplo) do que C++, porém a leitura de
dados com o C++ é muito mais facilitada, você terá agora a chance de tirar suas próprias
conclusões com nosso estudo de entrada e saida em C++.
Observe o código abaixo que é o equivalente ao código da Figura 3.4-7 :

Figura 3.4-16

Uma das grandes vantagens de se usar o stream de entrada cin do C++ é que não é necessário
especificar qual o tipo da variavel de entrada que esta sendo lida no momento, conforme o C
necessita com sua função scanf(“%d”, &idade) por exemplo.

C++ também da suporte a um tipo de dado chamado string, que basicamente é um tipo
destinado a representar um vetor de caracteres, um outro código equivalente ao anterior seria:

Figura 3.4-17
Obs: C não possui o tipo de dados string.

A partir de agora, todas as vezes que nos referirmos a uma cadeia/vetor de caracteres, e
palavra/frase neste texto, será usada a palavra string, a não ser que seja um exemplo
especifico para vetor de caracteres em C.

É notável que até o momento não inicializamos nem fizemos leitura de uma string com
espaços em branco, isto é, consegue-se ler o nome de uma pessoa mas não seu nome
completo. Porém o estudo de strings é tão imporante que veremos mais detalhadamente no
capitulo [*].

A linguagem C++ utiliza um header para manipular a forma de saida dos dados, a formatação
de saida não é tão pratica como em C que modifica apenas o printf, esse header é o
<iomanip>. A tabela a seguir mostra alguns modificadores mais utilizados:

Figura 3.4-18

http://www.cplusplus.com/reference/iomanip/

Como este é um livro de foco geral, para um estudo tão vasto quanto duas linguagens é
impossivel abordar cada detalhe, porém basta consultar os links a seguir para mais
manipuladores e parametros de manipulação de fluxo de saida no C++:

http://en.cppreference.com/w/cpp/io/manip

http://en.cppreference.com/w/cpp/io/basic_ostream
Figura 3.4-19

Vejamos agora outro código onde definimos a precisão de nossa saida utilizando alguns
manipuladores na nossa função cout.

3.5 - Operadores em C e C++


Operadores são os elementos que farão determinadas operações, porém, assim como na
matemática, os mesmos apresentam uma ordem de precedencia, isto é, por exemplo, a
operação de multiplicação (*) deve ser feita primeiro que a soma (+), de forma que o operador
(*) tem prioridade sobre o (+). Observe abaixo:
Figura 3.5-1

Percebe-se claramente que o operador * tem precedencia sobre o +, e o ( ) tem precedencia


sobre o *.

A seguir será apresentada uma tabela de precedencia para a linguagem C, onde a primeira
coluna significa a precedencia (nivel de prioridade), a segunda o operador, a terceira uma
breve descrição em ingles sobre onde se usa o operador, e a quarta o tipo de associação¹, da
esquerda para a direita (“left-to-right”) ou da direita para esquerda (“right-to-left”).

Obs¹: O tipo de associação remete a qual lado o operador vai se comportar ou caminha, por exemplo, o de
igualdade (=), atribui o numero que está a direita para uma variável que está na esquerda, ex: (x = 123), ja uma
soma (+) faz-se a operação progredindo-se da esquerda para direita, ex: (3 + 5 + 6), soma-se 3 com 5, depois 5
com 6, e não 6 com 5 e depois 5 com 3.
Tabela de precedencia de operadores da linguagem C:

Figura 3.5-2

http://en.cppreference.com/w/c/language/operator_precedence

Dá para deduzir da tabela que a operação de resto (%) vem primeiro que a operação de
atribuição (=).
Operadores mais comuns do C:

Figura 3.5-3

http://en.cppreference.com/w/c/language/operator_precedence

Vejamos agora, a tabela de precedencia de operadores da linguagem C++, é quase a mesma,


com exceção de alguns elementos presente no C++ que não existen no C, o new , delete e o
throw por exemplo são notáveis na comparação.

Tabela de precedencia de operadores da linguagem


C++:
Figura 3.5-4

http://en.cppreference.com/w/cpp/language/operator_precedence

Alem dos operadores mais usados de C da figura 3.5-3, o C++ também apresenta alguns
operadores especiais que são relacionados a nova sintaxe de funções ou ao paradigma da
orientação a objetos por exemplo, confira a seguir:

Tabela de operadores especiais do C++:


Figura 3.5-5

http://en.cppreference.com/w/cpp/language/operator_precedence

A principio, vamos nos focar mais nos comuns descritos na tabela 3.5-3.

3.6 – Exercícios para implementação


Utilizando os conceitos dos ultimos tópicos deste capitulo 3, e alguns novos que veremos nos
códigos, implementaremos uma série de exemplos práticos para reforçar os conceitos.

1) Considerando que o usuário informe o raio de um circulo,


determine à sua area.

Figura 3.1-2

Analisando o exercicio:
1) Como o usuário é quem vai entrar com o raio, deveremos usar uma função de entrada para
armazenar essa informação, além, é claro, de declarar uma variável de nome raio do tipo float
ou double (uma vez que podemos ter valores fracionarios) para receber esse valor.

2) O numero π é um numero que pode ser considerado uma constante na nossa


implementação, embora ele seja irracional, podemos aproxima-lo para determinado número
de casas decimais, utilizaremos #define para tal.

Obs: Poderiamos tambem, usar o header <math.h> que contem uma aproximacao muito precisa do numero π.

3) Devemos ter uma variável para armazenar o calculo da área, que também deve ser do tipo
float ou double, o nome area é bem sugestivo.

4) Para fazer o cálculo da area, utilizaremos o operador de atribuição (=) também o de


multiplicação (*);

5) Por fim, para mostrar o resultado utilizaremos uma função de saida, printf por exemplo.

Vamos ao código:

Figura 3.6-1

Na linha 1 temos a declaração do nosso mais utilizado header <stdio.h>.


Linha 2 usamos o pré-processador para definir pi como sendo 3.14159265359.
Linha 3 a nossa função main e linhas 4 e 11 as chaves representando o inicio e fim da mesma
Linha 5 temos a declaração das nossas variáveis utilizadas.
Linha 6 usamos a nossa função de saida de dados printf e na linha 7, a de leitura para ler o
raio, observe que, como é uma variavel do tipo float, utilizamos o %f, e também observe o
uso do & a esquerda de raio como é uma leitura atraves do scanf.
Na linha 8 estamos atribuindo o valor do calculo pi * raio * raio para a nossa variável area,
observe que a associação do operador (=) é da direita para esquerda, e que o da (*) é da
esquerda para direita, além deste ultimo ter precedencia sobre o (=), em suma, o compilador
interpreta essa linha da seguinte maneira:
1) Multiplica pi por raio.
2) Multiplica o valor agregado anteriormente pelo segundo raio.
3) Atribui o resultado agregado das três multiplicações e atribui a variável area.
Linha 9 imprimimos o nosso resultado na tela com uma precisa de 3 casas decimais, com o
parametro %.3f na função printf, e por fim o return 0 na linha 10 indicando o fim do nosso
código.

2) Determine o perímetro e a área de um retangulo com medidas


determinadas pelo usuário.

Figura 3.6-2

Analisando o exercicio:

1) Exercicio muito semelhante ao exercício anterior, só temos mais variáveis a serem lidas e
mais cálculos a serem feitos, vamos declarar as variáveis que serão lidas pelo usuário base e
altura do tipo float, e também as variáveis area e perimetro que armazenarão os cálculos do
tipo float.

2) Para variar um pouco da implementação do anterior, utilizaremos o C++ para fazer o


exercício.

Confira o código:

Figura 3.6-3
Na linha 1 temos o nosso header da linguagem C++ para entra e saida de dados <iostream>
similar a <stdio.h> em C, na linha 2 especificamos que iremos usar o espaço de nomes std,
que é o espaço de nomes de todos headers da biblioteca padrão do C++.
Linha 3 a nossa função principal e linha 5 a declaração das variáveis que serão usadas.
Na linha 6 usamos a função de saida cout para interagir com o usuário, e pularmos uma linha
utilizazndo a função endl.
Na linha 7 utilizando uma função de entrada de dados, fazemos a leitura de duas variaveis
consecutivamente.
Linha 8 e 9, temos a tribuição dos calculos realizados para as variaveis perimetro e area
respectivamente.