Slides CPP Cap04 v1

Programação Aplicada: C++
2 o Ano - 2 o Semestre
Diogo Chambel Lopes
Atlântica, Instituto Universitário
2022-2023
Programação Aplicada: C++ Atlântica, Instituto Universitário

Conteúdos programáticos
Capı́tulos do programa:
2. Hello, World!
3. Objetos, tipos e valores.
4. Computação.
Conteúdo dos slides adaptado do livro: Programming principles and practice
using C++, Bjarne Stroustrup, 2a edição, capı́tulo 4.

4. Computação.
4.1. Computação.
4.2. Objetivos e ferramentas.
4.3. Expressões.
4.4. Comandos (statements).
4.5. Funções.
4.6. Vetores.
4.8. Questões de revisão.
4.9. Exercı́cios.

4.1 Computação.
▶ Visto de forma simplificada, tudo o que um programa faz consiste em
receber dados de entrada, processar esses dados, e produzir dados de
saı́da (computação).
▶ O input (dados de entrada) pode ter origem em diferentes fontes:

teclado, rato, touch screen, ficheiros, outros programas, outras partes do
mesmo programa, teclados de música, câmaras de vı́deo, ligações de rede,
sensores de temperatura, máquinas fotográficas, etc.

4.1 Computação.
▶ O output (saı́da de dados) pode ser para o monitor, para ficheiros, para
ligações de rede, para outros programas, para outras partes do programa,
sintetizadores musicais, motores elétricos, geradores de energia elétrica,
aquecedores, etc.
▶ Do ponto de vista da programação, os casos mais importantes são de ou

para outro programa, e de ou para outras partes do mesmo programa,
sendo este último o foco desta disciplina: Como construimos um
programa como um conjunto de partes que cooperam partilhando e
trocando dados entre si?
▶ Graficamente:

4.1 Computação.
▶ A abreviação I/O significa input/output.
▶ Neste caso, o output de uma determinada parte do programa é o input da

parte seguinte.
▶ Aqui, as partes de um programa são entidades como funções que

produzem um resultado a partir de um conjunto de argumentos de
entrada, como por exemplo: a raiz quadrada de um número real (tipo
double), ou outra função qualquer.

4.2 Objetivos e ferramentas.
▶ O trabalho de um programador consiste em expressar as computações
necessárias de forma correta, simples e eficiente.
▶ Não é importante que um programa seja rápido, se produzir resultados

incorretos.
▶ Da mesma forma, se um programa estiver correto e for eficiente, poderá

ter de ser reescrito se for demasiado complexo (nova versão).
▶ Em geral, os programas estão sujeitos a evolução para se adaptarem a

novas necessidades, novo hardware, etc; e por essa razão devem ser
escritos de forma tão simples quanto possı́vel.
▶ A ferramenta principal que temos à nossa disposição para organizar um

programa consiste em dividir o programa em pequenos programas.

▶ Esta técnica apresenta duas variações:
▶ Abstração: Neste caso, os detalhes da implementação que não são

necessários para usar um determinado recurso são escondidos por
trás de uma interface conveniente. Por exemplo, em vez de
considerar os detalhes de como ordenar uma lista telefónica,
chamamos o algoritmo de ordenação da biblioteca padrão do C++.
Outro exemplo é a forma como usamos a memória do computador.
O uso direto da memória pode ser bastante confuso, por isso o
acesso é feito por meio de variáveis com nome, e vetores da
biblioteca padrão, etc.
▶ Dividir para conquistar (divide and conquer ): neste caso, um
problema grande é dividido em vários problemas pequenos. Por
exemplo, para construir um dicionário, podemos separar esse
trabalho em três: ler os dados, classificar os dados e gerar os dados.
Cada um dos problemas resultantes é significativamente menor do
que o original.

▶ Um programa com 1000 linhas tem muito mais de dez vezes mais erros
do que um programa com 100 linhas, e por essa razão tentamos escrever
o programa de 1000 linhas a partir de partes com menos de 100 linhas.
▶ Para programas maiores (10 000 000 linhas, por exemplo) a aplicação dos
dois princı́pios descritos no slide anterior não é apenas uma opção, é um
requisito essencial.
▶ Quando pensamos em dividir um programa, devemos considerar sempre
quais são as ferramentas que temos disponı́veis para expressar as
diferentes partes do programa e como esta comunicam entre si.
▶ Uma boa biblioteca, com recursos úteis para expressar ideias, pode afetar
significativamente a forma com distribuı́mos funcionalidade por diferentes
partes de um programa.
▶ Exemplo de abstração: a biblioteca iostream poupa-nos tempo uma vez
que não temos de lidar diretamente com as portas de entrada e saı́da do
hardware.
4.3 Expressões.
▶ O bloco de construção mais básico de um programa é uma expressão.
▶ Uma expressão computa um valor a partir de conjunto de operandos.
▶ A expressão mais simples consiste num valor literal, como 10, ’a’ , 3.14 ,
ou ”Norah”.
▶ Os nomes das variáveis também são expressões.
▶ Nos exemplos abaixo os valores literais 20 e 40 são usados para inicializar

as variáveis length (comprimento) e width (largura), que são depois
multiplicados entre si.

4.3 Expressões.
▶ No exemplo seguinte, o operando length no lado esquerdo do operador de
atribuição significa: o objeto denominado comprimento.
▶ Deste modo que a expressão de atribuição é lida como: coloque 99 no

objeto denominado length.
▶ É necessário distinguir entre o objeto usado no lado esquerdo de uma

atribuição ou inicialização (lvalue), e o valor do objeto usado no lado
direito de uma atribuição ou inicialização (rvalue).
▶ Ou seja, length é o nome de um objeto do tipo int que contém o valor 99.

4.3 Expressões.
▶ Podemos construir expressões mais complexas combinando expressões por
meio de operadores como + e ∗, da forma usual.
▶ Quando necessário, podemos usar parêntesis para agrupar expressões.
▶ São aplicáveis as regras habituais de precedência dos operadores
matemáticos. Exemplos:
▶ length + width ∗ 2 é o mesmo que length + (width ∗ 2).
▶ a ∗ b + c/d é o mesmo que (a ∗ b) + (c/d) mas não é o mesmo que
a ∗ (b + c)/d.
▶ Em caso de dúvida, podemos sempre usar parêntesis, mas o seu uso
excessivo torna as expressões mais difı́ceis de ler: (a ∗ b) + (c/d).
▶ Se o código for difı́cil de ler, é mais difı́cil verificar se está correto, e por
isso devemos escolher nomes significativos e não devemos escrever
expressões demasiado complicadas como:

4.3 Expressões.
Expressões constantes
▶ Tipicamente, os programas utilizam um grande número de constantes.
▶ Por exemplo, um programa de geometria pode utilizar o valor de π e um

programa que converta polegadas para centı́metros irá utilizar o fator de
conversão 2.54.
▶ Obviamente, queremos utilizar nomes que indiquem o significado destas

constantes.
▶ Da mesma forma também não queremos que os valores destas constantes

sejam alterados acidentalmente.
▶ Em C++, uma constante simbólica é tipo de objeto com nome associado

cujo valor não pode ser alterado após a sua inicialização. Por exemplo:

4.3 Expressões.
▶ Estas constantes são úteis para que o código seja mais fácil de ler, uma
vez que os valores de determinadas constantes no meio do código podem
não ser reconhecı́veis à primeira vista, ao contrário do seu nome.
▶ Por exemplo, o valor de π pode ser definido de diferentes formas

consoante o nı́vel de precisão necessário (3.14, 22/7, etc.), o que pode
fazer com que seja difı́cil de encontrar no código, se for utilizado o valor
em vez do nome da constante.
▶ É preferı́vel definir π através de uma constante com o valor apropriado.

4.3 Expressões.
▶ Na definição de uma constante simbólica através de constexpr tem de ser

atribuı́do um valor a essa constante que é conhecido aquando da
compilação.

4.3 Expressões.
▶ Para lidar com casos em que o valor de uma constante deverá ser
inicializada com um valor que não é conhecido aquando da compilação,
mas que nunca é alterado após a sua inicialização, em C++ existe uma
outra forma de constante (const):

4.3 Expressões.
▶ As constantes do tipo const são muito comuns por duas razões:
1. A opção constexpr não estava presente no padrão C++98.
2. As constantes que não são conhecidas inicialmente, mas cujo valor

não é alterado após a sua inicialização podem ser muito úteis.

4.3 Expressões.
Operadores
▶ Até agora utilizámos os operadores mais simples, no entanto, para

operações mais complexas, serão necessários outros operadores.
▶ A maioria dos operadores são convencionais, e serão apresentados mais

tarde à medida que vão sendo necessários.
▶ Os operadores mais comuns estão listados no slide seguinte (lval é o

mesmo que lvalue).

4.3 Expressões.
Operadores

4.3 Expressões.
Operadores
▶ Um incremento pode ser expresso de pelo menos três formas diferentes:
▶ Os compiladores modernos tendem a gerar exatamente o mesmo código

para a = a + 1 e + + a quando a pertence a um dos tipos básicos (built-in
types), que incluem int, double, char, e bool (apêndice A8 do livro).
▶ a∗ = scale tem o mesmo resultado de a = a ∗ scale.

4.3 Expressões.
Conversões
▶ Podemos combinar tipos diferentes na mesma expressão. Por exemplo:

2.5/2 é um double dividido por um int.
▶ Neste caso, à primeira vista parece não estar definido se se trata da

divisão inteira ou de números reais (floating-point)
▶ A divisão inteira descarta o resto da divisão: 5/2 é igual a 2.
▶ No caso da divisão de dois números reais (floating-point division):

5.0/2.0 é igual a 2.5.
▶ A regra para os tipos que apresentados até agora é que se um operador

tem um operando do tipo double é produzido um resultado do tipo
double, caso contrário é produzido um resultado do tipo int.

4.3 Expressões.
Conversões
▶ Exemplos:
▶ As notações tipo(valor) e tipo{valor} significam: converter valor para

tipo, ou seja, se necessário, o compilador converte operandos do tipo int
para o tipo double ou do tipo char para o tipo int.
▶ A notação tipo{valor } previne a truncatura de um valor em resultado de

uma conversão insegura, ao contrário de tipo(valor ).

4.3 Expressões.
Conversões
▶ Uma vez que o resultado foi calculado, o compilador pode ter que
convertê-lo (novamente) para usá-lo como um inicializador ou o braço
direito de uma atribuição. Exemplos:

4.3 Expressões.
Conversões
▶ Considere a fórmula habitual para a conversão de graus Celsius para graus

Fahrenheit: f = 9/5 ∗ c + 32. Podemos escrever:
▶ Este código não representa uma conversão exata da temperatura uma vez
que 9/5 é igual a 1 em vez de 1.8.
▶ Para corrigir o código, o 9 ou o 5 (ou ambos) têm de ser modificados

para um double:

4.4 Comandos (statements).
▶ Até agora, vimos dois tipos de comandos: expressões e declarações.
▶ Um constituı́do por uma expressão é simplesmente uma expressão seguida

de ponto-e-virgula (semicolon). Exemplos:
▶ = é o operador de atribuição, a = b é uma expressão, e a = b; é um

comando.
▶ Sem o ponto-e-virgula, no exemplo abaixo, o compilador não saberia que

querı́amos dizer a=b++; b; ou a=b; ++b;.
▶ Pontuação. Quem come quem nas expressões:

▶ man eating tiger!
▶ man-eating tiger!

▶ O computador executa os comandos na ordem em que são escritos.
▶ No exemplo seguinte, a declaração de a, com a respetiva inicialização, é

executada antes do comando de saı́da.
▶ Ao contrário dos exemplos seguintes, que normalmente são erros lógicos

que são detetados pelo compilador, em geral queremos que um comando
tenha algum efeito.
▶ Assim, as expressões de comandos são normalmente atribuições,

comandos de I/O ou chamadas de funções.

▶ Existe um outro tipo de comando, que por não ter nenhuma consequência
é chamado comando vazio (empty statement).
▶ Este tipo de comandos, apesar de serem legais em C++, normalmente

tratam-se de erros, como no caso do ; na primeira linha do exemplo
seguinte:
▶ Neste exemplo o compilador testa x para verificar se o seu valor é igual a

5, e se esta condição for verdadeira, será executado o comando vazio, sem
qualquer efeito.
▶ Por outro lado, se x não for igual a 5, o compilador não executa o

comando vazio, e consequentemente, este comando não tem qualquer
efeito em nenhum do casos.

Seleção
▶ Nos programas, como na vida, muitas vezes temos que escolher entre
alternativas.
▶ Em C++, esta escolha é implementada com comandos if ou com

comandos switch.
Comando if
▶ A forma mais simples de seleção é um comando if, que seleciona entre

duas alternativas, como no exemplo do slide seguinte.

Comando if
#include<iostream>
using namespace std;
int main()
{
int a = 0;
int b = 0;
cout << "Insira dois inteiros\n";
cin >> a >> b;
if (a<b) // condicao
// primeira alternativa (condicao verdadeira):
cout << "max(" << a << "," << b <<"): " << b <<"\n";
else
// segunda alternativa (condicao falsa):
cout << "max(" << a << "," << b <<"): " << a << "\n";
}

Comando if
▶ Um comando if escolhe entre duas alternativas. Se a condição for

verdadeira é executado o primeiro comando, caso contrário é executado o
segundo comando.
▶ O mesmo acontece com muitos casos na vida real:

▶ Semáforo verde: avançar.
▶ Semáforo vermelho: parar.
▶ Em C++:
▶ Procure o que está errado no código do slide seguinte.

Comando if
// converter polegadas para centimetros e centimetros para polegadas

#include<iostream>
int main()
{
constexpr double cm_per_inch = 2.54; // centimetros por polegada
double length = 1; // comprimento em centimetros ou polegadas
char unit = 0;
cout << "Insira um comprimento seguindo de uma unidade (c ou i):\n";
cin >> length >> unit;
if (unit == ’i’)
cout << length << "in == " << cm_per_inch*length << "cm\n";
else
cout << length << "cm == " << length/cm_per_inch << "in\n";
}

Comando if
▶ Experimente o programa anterior inserindo 1i (resultado: 1in ==

2.54cm), e 2.54c (resultado: 2.54cm == 1in).
▶ Este programa não considera a possibilidade de os dados de entrada

serem incorretos, e não verifica se a unidade é mesmo ’c’.
▶ Experimente o programa inserindo 15f e verifique o resultado.
▶ Devemos considerar sempre os dados de entrada incorretos que podem ser

fornecidos aos programas, de forma intencional ou acidental.
▶ No slide seguinte é apresentada uma versão melhorada do mesmo

programa.

Comando if

#include<iostream>
int main()
{
char unit = ’ ’; // um espaco nao e uma unidade
cout<< "Insira um comprimento seguindo de uma unidade (c ou i):\n";
if (unit == ’i’)
else if (unit == ’c’)
else
cout << "unidade desconhecida: " << unit << "\n";
}

Comando if
▶ O programa anterior testa primeiro para unit == ’i’, depois para unit ==
’c’ e se não for um destes casos a saı́da é uma mensagem que informa
deste facto.
▶ Pode parecer que foi usado um comando else-if, mas este não existe em
C++.
▶ Em vez disso, foram combinados dois comandos if, cuja forma geral é:
▶ Neste caso foi usado um comando if na parte else do primeiro comando

if:

Comando switch
▶ Na realidade, a comparação de unit com ’i’ e ’c’ é um exemplo da forma

mais comum de seleção: uma seleção baseada na comparação de um
valor com diferentes constantes.
▶ Por este tipo de seleção ser tão comum, existe em C++ um comando
especial para o efeito: o comando switch.
▶ O código anterior pode ser modificado para utilizar um comando switch,

como mostrado no slide seguinte.

Comando switch

#include<iostream>
int main()
{
char unit = ’a’;
cout<< "Insira um comprimento seguindo de uma unidade (c ou i):\n";
switch (unit) {
case ’i’:
break;
case ’c’:
break;
default:
cout << "unidade desconhecida: " << unit << "\n";
break;
}
}

Comando switch
▶ Sintaxe do comando switch:
▶ O valor entre parêntesis depois de switch é comparado com um

conjunto de constantes.
▶ Cada constante é apresentada depois de um case.
▶ Se o valor for igual à constante, é escolhido o comando associado
ao respetivo case.
▶ Cada case é terminado por um break.
▶ Se o valor não corresponder a nenhuma das clausulas case, é
escolhido o comando identificado pela clausula default.
▶ Não é obrigatório incluir uma clausula default, mas é boa ideia fazê-lo, a
não ser que tenhamos a certeza de que todas as alternativas foram
listadas.

Detalhes técnicos do comando switch
▶ Alguns detalhes técnicos sobre os comandos switch:
1. O valor que usamos no switch deve ser do tipo int, char ou enum
(capı́tulo 9). Não pode ser usada uma string.
2. Os valores nas clausulas case devem ser expressões constantes. Não
podem ser usadas variáveis.
3. Não pode ser usado o mesmo valor para duas clausulas case.
4. Podem ser usadas várias clausulas case para o mesmo caso
(conjunto de instruções).
5. Cada case deve ser terminado com um break. Infelizmente,
provavelmente o compilador não o avisa se se esquecer.
▶ Ver exemplo no slide seguinte.

#include<iostream>
int main()
{
cout << "Gosta de peixe?\n";
string s;
cin >> s;
switch (s) { // erro: o valor tem de ser do tipo int, char, ou enum
case "nao":
// . . .
break;
case "sim":
// . . .
break;
}
}

▶ Para uma seleção com base numa string, deve ser usado um comando if
ou um mapa (capı́tulo 21), uma vez que o comando switch gera um
código otimizado para comparação com um conjunto de constantes.
▶ Para grandes conjuntos de constantes, normalmente é produzido um

código mais eficiente com um comando switch do que com um conjunto
de comandos if.
▶ No entanto, isto significa que os valores das clausulas case devem ser
constantes e distintos, como no exemplo do slide seguinte.


▶ Frequentemente, queremos que a mesma ação seja executada para um

conjunto de valores de um switch.
▶ Neste caso, o mesmo conjunto de instruções pode ser associado a várias

clausulas case, como no exemplo do slide seguinte.

#include<iostream>
int main()
{
cout << "Insira um digito\n";
char a;
cin >> a;
switch (a) {
case ’0’: case ’2’: case ’4’: case ’6’: case ’8’:
cout << "par\n";
break;
case ’1’: case ’3’: case ’5’: case ’7’: case ’9’:
cout << "impar\n";
break;
default:
cout << "nao e um digito\n";
break;
}
}

▶ O erro mais comum nos comandos switch é a omissão de um break em
cada case. Exemplo:
#include<iostream>
int main()
{
char unit = ’a’;
cout << "Insira um comprimento seguindo de uma unidade (c ou i):\n";
switch (unit) {
case ’i’:
case ’c’:
}
}

▶ Infelizmente, o compilador aceita isto, e quando termina o case ’i’, passa

diretamente para o case ’c’, de modo que se se inserir 2i, o programa
produz:

Comando while
▶ Considere o primeiro programa que foi executado num computador com o

programa armazenado (o EDSAC).
▶ Este programa escrito e executado por David Wheeler no laboratório de

informática da Universidade de Cambridge, Inglaterra, a 6 de maio de
1949, para calcular e imprimir uma lista simples de números ao quadrado:

Comando while
▶ Cada linha é um número seguido por um carácter de tabulação (tab,

’\t’), seguido pelo quadrado do número.
▶ Uma versão em C++:
#include<iostream>
#include<cmath> // pow(base,expoente)
int main()
{
int i = 0;
while (i<100) {
cout << i << ’\t’ << pow(i,2) << ’\n’;
++i; // incrementar i
}
}

Comando while
▶ O comando while é seguido de uma condição e do seu corpo:
▶ O corpo do ciclo (loop) é um bloco delimitado por chavetas que imprime

uma linha da tabela e incrementa a variável do ciclo, i.
▶ A condição i < 100 é testada no inı́cio de cada iteração do ciclo, e caso

seja verdadeira, o corpo do ciclo é executado.
▶ A variável da condição do comando while deve ser definida e inicializada

antes do comando while e se a variável não for definida previamente, o
compilador produz um erro.
▶ Se a variável for definida mas não for inicializada, a maioria dos

compiladores produz um aviso, mas permite executar o programa.
▶ Variáveis não inicializadas são uma fonte comum de erros.

Exercı́cio (try this)
▶ O carácter ’b’ é igual a char(’a’+1), ’c’ é char (’a’+2), etc.
▶ Use um ciclo para escrever uma tabela de caracteres com os seus valores
inteiros correspondentes de a a z.
Blocos
▶ Uma sequência de comandos delimitados por chavetas { } é chamada

bloco ou comando composto, como no caso do while do código abaixo:
while (i<100) {
cout << i << ’\t’ << pow(i,2) << ’\n’;
++i; // incrementar i
}

Blocos
▶ Por vezes, um bloco vazio { } é útil para expressar que nada deve ser
feito. Exemplo:
if (a<=b) { // nada a fazer

}
else { // permutar a e b
int t = a;
a = b;
b = t;
}

Comandos for
▶ Um ciclo baseado numa sequência de números é tão comum que C++,
como a maioria das outras linguagens de programação, possui uma
sintaxe especial para este tipo de ciclo.
▶ Uma instrução for é como uma instrução while, mas os parâmetros da
variável de controlo estão concentrados junto ao comando for, sendo mais
fácil de visualizar e entender.
▶ O programa inicial poderia ter sido escrito como:
#include<iostream>
int main()
{
for (int i = 0; i<100; ++i)
cout << i << ’\t’ << pow(i,2) << ’\n’;
}
Comandos for
▶ O comando for no código anterior significa: executar o corpo com i
começando em 0 incrementando i após cada execução do corpo até que i
seja igual a 100.
▶ Um comando for é sempre equivalente a algum comando while, e neste
caso, os dois conjuntos abaixo são equivalentes.
for (int i = 0; i<100; ++i)
cout << i << ’\t’ << pow(i,2) << ’\n’;
int i = 0; // inicializacao do for

while (i<100) { // condicao do for
cout << i << ’\t’ << pow(i,2) << ’\n’; // corpo do for
++i; // incremento do for
}

Comandos for
▶ Sempre que seja possı́vel usar um for ou um while, é preferı́vel usar um

for.
▶ A variável do ciclo for não deve ser modificada no interior do corpo do

comando for. Exemplo:
#include<iostream>
#include<cmath>
int main()
{
for (int i = 0; i<100; ++i) {
cout << i << ’\t’ << pow(i,2) << ’\n’;
++i; // deve ser um erro!
}
}

Comandos for
▶ À primeira vista parece que o corpo do ciclo no exemplo anterior é
executado 100 vezes, mas não isso que acontece.
▶ O ++i no corpo faz com que i seja incrementado duas vezes a cada
iteração do ciclo, de modo a que obtenhamos uma saı́da apenas para os
50 valores pares de i.
▶ Para incrementar a variável do ciclo em 2 a cada iteração devemos fazê-lo
explicitamente:
#include<iostream>
int main()
{
for (int i = 0; i<100; i+=2)
cout << i << ’\t’ << pow(i,2) << ’\n’;
}
4.5 Funções.
▶ No programa anterior, pow(i,2) é a chamada de uma função chamada
pow cujos argumentos são i e 2.
▶ Uma função é uma sequência de comandos, associada a um nome.
▶ Uma função pode devolver um resultado, chamado valor de retorno.
▶ A biblioteca padrão fornece várias funções úteis, como a função sqrt()

que calcula a raiz quadrada, e que usámos anteriormente.
▶ Para além das funções definidas na biblioteca padrão do C++, também

podemos escrever as nossas próprias funções, como a do exemplo abaixo
que calcula o quadrado de um número.
int quadrado (int x) {

return x*x;
}

4.5 Funções.
▶ No exemplo do slide anterior, na primeira linha os parênteses indicam que
se trata de uma função, cujo nome é square, que recebe um argumento
do tipo int chamado x, e que devolve um int (indicado antes do nome na
declaração da função. A função pode ser chamada desta forma:
int main(x) {
cout << quadrado(2) << ’\n’; // escreve 4
cout << quadrado(10) << ’\n’; // escreve 100
}
▶ Não temos de usar o resultado da chamada de função, mas temos que dar
à função exatamente os argumentos que ela requer. Considere:
quadrado(2); // provavelmente um erro: valor de retorno nao usado

int v1 = quadrado(); // erro: argumento em falta
int v2 = quadrado; // erro: parenteses em falta
int v3 = quadrado(1,2); // erro: demasiados argumentos
int v4 = quadrado("two"); // erro: tipo de argumento errado

4.5 Funções.
▶ Muitos compiladores alertam contra resultados não utilizados de funções
e todos indicam os erros indicados no slide anterior.
▶ O corpo da função é o bloco entre chavetas { } que na realidade faz o

cálculo:
{
return x*x; // devolve o quadrado de x
}
▶ A sintaxe de uma definição de função pode ser descrita assim:
tipo identificador (lista-de-par^

ametros) corpo-da-funç~
ao
▶ Ou seja, um tipo de retorno, seguido de um identificador (o nome da

função), seguido por uma lista de parâmetros entre parênteses, seguido
pelo corpo da função (as instruções a serem executadas).

4.5 Funções.
▶ A lista de parâmetros pode estar vazia e, se não quisermos que a função

devolva um resultado, colocamos void como o tipo de retorno. Exemplo:
▶ Os aspectos técnicos das funções são analisados em detalhe no capı́tulo 8.

4.5 Funções.
Porquê funções?
▶ Definimos uma função quando queremos um cálculo separado com um

nome, uma vez que:
▶ Torna o cálculo logicamente separado.

▶ Torna o texto do programa mais claro, pela denominação do
cálculo.
▶ Torna possı́vel usar a função em mais de que um sı́tio no nosso
programa.
▶ Facilita o teste do programa.

4.5 Funções.
Porquê funções?
▶ Os programas no mundo real usam milhares de funções, alguns até

centenas de milhares de funções.
▶ Não serı́amos capazes de escrever ou compreender estes programas se

suas as partes não estivessem claramente separadas e denominadas.
▶ Além disso, muitas funções são utilizadas repetidamente, e não faria

sentido repetir várias vezes o mesmo código.
▶ Os programas são geralmente mais fáceis de escrever e entender se cada

função executar uma única ação lógica.

4.6 Vector(es).
▶ Para fazer praticamente qualquer coisa de interesse num programa,
precisamos de um conjunto de dados para trabalhar.
▶ Por exemplo, podemos precisar de uma lista de números de telefone, uma

lista de membros de uma equipa de futebol, uma lista de cursos, uma
lista de livros lidos no último ano, um catálogo de músicas para
download, um conjunto de opções de pagamento para um carro, uma lista
de previsões do tempo para a próxima semana, uma lista de preços de
uma câmara em diferentes lojas, etc.
▶ Veremos várias formas de armazenar dados e uma das formas mais

simples é por meio de um vector.
▶ Um vector é simplesmente uma sequência de elementos que podem ser

acedidos através de um ı́ndice.

4.6 Vector(es).
▶ Por exemplo, para um vector chamado v :
▶ Ou seja, o ı́ndice do primeiro elemento é 0, o do segundo é 1, e assim

sucessivamente.
▶ Referimo-nos a um elemento do vector através do nome do vector com o

ı́ndice do elemento entre parênteses retos, e neste exemplo o valor de v[0]
é 5, o valor de v[1] é 7, e assim sucessivamente.
▶ Os ı́ndices de um vector começam sempre em 0 e o incremento é 1.

4.6 Vector(es).
▶ Para definir um vector é necessário especificar o tipo dos elementos e o
conjunto inicial de elementos. Exemplo:
▶ O tipo de elemento vem depois da palavra vector entre os sı́mbolos < >,
é neste caso é <int>.
▶ Outro exemplo:
▶ Naturalmente, um vector aceitará apenas elementos do seu tipo

declarado de elemento:

4.6 Vector(es).
▶ Também podemos definir um vector de um determinado tamanho sem
especificar os valores dos elementos.
▶ Nesse caso, usamos a notação (n) em que n é o número de elementos, e

os elementos recebem um valor por defeito de acordo com o tipo de
elemento. Por exemplo:
▶ A string sem caracteres “ ” é chamada string vazia.
▶ O valor de inicialização por defeito também pode ser alterado. Este

exemplo cria um vector de 1000 doubles, todos inicializados com −1.2:
vector<double> vi(1000,-1.2)

4.6 Vector(es).
▶ Não podemos simplesmente referir-nos a um elemento inexistente de um

vector (run-time error == erro de execução):
▶ O tamanho de um vector pode ser obtido como mostrado no exemplo

seguinte, que imprime todos os elementos de um vector:

4.6 Vector(es).
Percorrendo um vector
▶ A chamada de v.size() fornece o número de elementos do vector com o

nome v .
▶ Em geral, v.size() permite aceder aos elementos de um vector sem nos

referir-nos acidentalmente a um elemento fora do intervalo do vector.
▶ O primeiro elemento de v é v[0] e o último elemento de v é [v.size()-1].
▶ Se v.size == 0, v não possui elementos, ou seja, v é um vector vazio.
▶ O ciclo (loop) no exemplo seguinte percorre todos os elementos do vector

v . (int x: v) significa: para cada int x em v.

4.6 Vector(es).
Aumentar um vector
▶ Frequentemente, iniciamos um vector vazio que é depois aumentado até

o tamanho desejado à medida que lemos ou calculamos os dados que
queremos colocar no mesmo.
▶ A operação principal neste caso é push back(), que adiciona um novo

elemento a um vector.
▶ O novo elemento torna-se o último elemento do vector, como ilustrado

no slide seguinte.

4.6 Vector(es).

4.6 Vector(es).
Aumentar um vector
▶ push back() é uma função membro de vector e deve ser chamada esta
notação com ponto:
▶ O tamanho do vector pode ser obtido por uma chamada de outra funções
membro de vector: size().
▶ Inicialmente v.size () era igual a 0, e após a terceira chamada de

push back(), v.size() ficou igual a 3.
▶ Um vector é semelhante a uma matriz em C e outras linguagens, no

entanto não é necessário especificar o tamanho de um vector com
antecedência e podemos adicionar mais elementos em qualquer altura.

4.6 Vector(es).
Um exemplo numérico
▶ Frequentemente, temos um conjunto de dados que queremos ler e
processar no nosso programa.
▶ Podemos querer usar os dados para produzir um gráfico dos valores,
calcular a média e a mediana, encontrar o maior elemento, ordená-los,
combiná-los com outros dados, procurar determinados valores,
compará-los com outros dados, etc., mas primeiro é necessário colocá-los
na memória do computador. Exemplo:

4.6 Vector(es).
▶ No exemplo do slide anterior são lidos vários números do tipo double que
representam temperaturas.
▶ Primeiro é declarado um vector para guardar os dados, e é aqui que o

tipo desejado de dados de entrada é declarado:
▶ De seguida, no ciclo lemos e armazenamos os valores desejados:
▶ temp é uma variável temporária do tipo double que é usada para leitura
de cada valor: cin >> temp.

4.6 Vector(es).
▶ O valor de temp é depois colocado no final do vector (último elemento)

através da função push back().
▶ A novidade aqui é que cin >> temp pode ser usado como condição num
comando for.
▶ Neste caso, cin >> temp é verdadeiro se um valor foi lido corretamente e
falso caso contrário, de modo que o comando lê todos os valores do tipo
double que fornecemos e para quando é fornecido outro tipo de dado.
▶ Por exemplo, se ao correr o programa inserirmos a sequência seguinte, o

carácter ’|’ termina o ciclo, uma vez que não é um double.

4.6 Vector(es).
▶ A mesma tarefa pode ser executada com um ciclo while em vez de um

ciclo for (no caso do for o scope de temp é limitado ao interior do ciclo).
▶ Uma vez que tenhamos os dados num vector, podemos manipulá-los

facilmente, como no exemplo do slide seguinte, que calcula a média e a
mediana da temperaturas.

4.6 Vector(es).
// calcular media e mediana da temperatura VERSAO 1
#include<iostream>
#include<vector>
#include<algorithm> //sort
int main()
{
vector<double> temps; // temperaturas
for (double temp; cin>>temp; ) // ler para temp
temps.push_back(temp); // colocar temp no vector
// temperatura media
double sum = 0;
for (int i=0; i<temps.size(); i++) sum += temps[i];
cout << "temperatura media: " << sum/temps.size() << ’\n’;
// mediana
sort(temps.begin(),temps.end()); // ordenar temperaturas
cout << "mediana: " << temps[temps.size()/2] << ’\n’;
}

4.6 Vector(es).
// calcular media e mediana da temperatura VERSAO 2
#include<iostream>
#include<vector>
#include<algorithm> //sort
int main()
{
vector<double> temps; // temperaturas
for (double temp; cin>>temp; ) // ler para temp
temps.push_back(temp); // colocar temp no vector
// temperatura media
double sum = 0;
for (double x : temps) sum += x;
cout << "temperatura media: " << sum/temps.size() << ’\n’;
// mediana
sort(temps.begin(),temps.end()); // ordenar temperaturas
cout << "mediana: " << temps[temps.size()/2] << ’\n’;
}

4.6 Vector(es).
▶ A média é calculada simplesmente somando todos os elementos e

dividindo a soma pelo número de elementos, ou seja, temps.size ().
▶ Note a utilização do operador +=.
▶ Para calcular a mediana é necessário ordenar os elementos do vector, e

para esse efeito é usada a função sort() da biblioteca padrão do C++.
▶ Depois de ordenadas as temperaturas, a mediana é simplesmente o

elemento do meio, com ı́ndice temps.size()/2.
▶ O resultado obtido não é exatamente a mediana se o número de

elementos do vector for par (ver exercı́cio 2 no final do caı́tulo).

4.6 Vector(es).
Um exemplo de texto
▶ Considere o exemplo abaixo (ordenação de palavras):
// ordenar palavras
// terminar entrada de dados com Ctrl+z
#include<iostream>
#include<vector>
#include<algorithm> // sort
int main() {
vector<string> words;
string temp;
while (cin>>temp) // ler palavras separadas por espacos
words.push_back(temp); // colocar no vector
cout << "numero de palavras: " << words.size() << ’\n’;
sort(words.begin(),words.end()); // ordenar as palavras alfabeticamente
for (int i = 0; i<words.size(); ++i)
if (i==0 || words[i-1]!=words[i]) // palavra nova?
cout << words[i] << "\n";
}

4.6 Vector(es).
Um exemplo de texto
▶ Se fornecermos algumas palavras a este programa, as palavras são
ordenadas, e escritas no monitor sem incluir palavras repetidas.
Experimente:
▶ O resultado será:
▶ Ao contrário do que acontece com números, qualquer carácter de entrada

pode ser considerado como uma string, e por isso, para terminar a
entrada de strings precisamos de um carácter especial que não seja uma
string:
⇒ Ctrl+z termina uma sequência de input em Windows e Ctrl+d tem a
mesma função em unix.
4.8 Questões de revisão.
1. O que é uma computação?
2. O que queremos dizer com entradas e saı́das de uma computação? Dê

exemplos.

▶ Uma computação consiste em produzir resultados (output) a partir

de determinados dados de entrada (input).

exemplos.

▶ Uma computação consiste em produzir resultados (output) a partir

de determinados dados de entrada (input).

exemplos.
▶ As entradas (input) são os dados que vão ser processados para

produzir as saı́das (output). Os dados de input podem ter origem
no teclado, rato, ficheiros, ligações de rede, outros programas,
outras partes do mesmo programa, sensores, etc. Os dados de
output podem ser enviados para o ecrã, para ficheiros, ligações de
rede, outros programas, outras partes do programa, controlo
motores elétricos, ar condicionado, etc.

3. Quais são os três requisitos que um programador deve ter em mente ao
expressar uma computação?
4. O que faz uma expressão?
5. O que é um valor literal?

▶ Uma computação deve ser correta (produzir resultados corretos),

simples (evitar complexidade desnecessária), e eficiente (tempo de
computação e utilização de memória).


▶ Uma expressão calcula (computa) um valor a partir de um conjunto

de operandos.


▶ Uma expressão calcula (computa) um valor a partir de um conjunto

de operandos.
▶ É a representação de um valor de determinado tipo (int, double,

string, etc.).

6. O que é uma constante simbólica e porque as usamos?
7. Indique alguns operadores que podemos aplicar a ints e a doubles.
8. Que operadores podem ser usados em inteiros, mas não em doubles?

▶ Uma constante simbólica é um objeto com nome associado (const,

constexpr), cujo valor não pode ser alterado após a sua inicialização.
As constantes simbólicas são usadas para evitar a repetição de
valores literais no código cujo significado poderá não ser óbvio,
manter a coerência do número de casas decimais na definição da
constante (pi, por exemplo), etc.


▶ =, +, ==, -, /, etc.


▶ =, +, ==, -, /, etc.
▶ % (resto), %= (b%=9 significa b=b%9).

9. Indique alguns operadores que podem ser usados para strings.
10. Indique uma situação em que um programador preferiria um comando

switch a um comando if.
11. Indique alguns problemas comuns que ocorrem com os comandos switch.

▶ =, + (concatenação), ==, <, <=, !=, etc.



▶ Se o número de condições a avaliar (casos) for elevado, e cada caso

corresponder ao valor de uma constante (int, char).


▶ Se o número de condições a avaliar (casos) for elevado, e cada caso

corresponder ao valor de uma constante (int, char).
▶ omissão de “break” no final de cada case.

12. Indique a função de cada parte da linha de cabeçalho de um ciclo for, e
em que sequência são executadas.
13. Em que situações deve ser usado um ciclo for e em que situações deve ser
usado um ciclo while?
14. Como se pode imprimir o valor numérico de um char?

▶ for (int i = 0; i<100; i+=2).
Valor inicial do contador: int i = 0
Condição limite do contador: i<100
Incremento do contador: i+=2

▶ for (int i = 0; i<100; i+=2).
▶ Ciclo for: nº de iterações definido à partida.
Ciclo while: nº de iterações definido por uma determinada condição.

▶ for (int i = 0; i<100; i+=2).
▶ Ciclo for: nº de iterações definido à partida.
Ciclo while: nº de iterações definido por uma determinada condição.
▶ int{’a’}
15. Na definição de uma função descreva o que significa a linha:
char foo (int x)
16. Em que situações se deve definir uma função em separado como parte de
um programa?
17. Indique o que se pode fazer com um int que não se pode fazer com uma
string?

char foo (int x)
▶ foo é o nome da função, char é o tipo de dados de retorno, x é o

parâmetro de input, e int é o tipo de dados de input.
um programa?
string?

char foo (int x)

um programa?
▶ Quando um conjunto de comandos é repetido várias vezes no

programa.
string?

char foo (int x)

um programa?
▶ Quando um conjunto de comandos é repetido várias vezes no

programa.
string?
▶ Operações matemáticas como: + (soma), -, *, /, ++ (incremento),

etc.
18. Indique o que se pode fazer com uma string que não se pode fazer com
um int?
19. Qual é o ı́ndice do terceiro elemento de um vetor?
20. Indique como se pode escrever um loop que imprime todos os elementos
de um vetor?

um int?
▶ + (concatenação), ordenação de palavras, etc.
de um vetor?

um int?
▶ 2.
de um vetor?

um int?
▶ 2.
de um vetor?
▶ vector<int> v = {5, 7, 9, 4, 6, 8};

for (int i=0; i<v.size(); ++i)
cout << v[i] << ’\n’;

21. O que faz: vector<char> alfabeto (26); ?
22. Descreva o que faz push back() aplicado a um vetor.
23. O que faz a função membro de vector: size() ?
24. Como se podem ordenar os elementos de um vetor?

▶ Cria um vetor, do tipo char, chamado alfabeto, com 26 elementos.

▶ Acrescenta um novo elemento no final de um vetor.

▶ Devolve o tamanho (n de elementos) do vetor.

▶ Devolve o tamanho (n de elementos) do vetor.
▶ Com a função sort: sort(temps.begin(),temps.end());

4.9 Prática (Drill).
1. Escreva um programa que consista num ciclo (loop) while que leia (a
cada iteração do ciclo) dois ints e depois os escreva para o monitor.
Termine o programa quando for lido um carácter ’|’.
2. Altere o programa para escrever “o menor valor é: ” seguido do menor dos
números e “o maior valor é: ” seguido pelo maior valor.
3. Aumente o programa de modo a que escreva “os números são iguais”,

caso sejam iguais.
4. Altere o programa de modo a que use doubles em vez de ints.
5. Altere o programa para que escreva “os números são quase iguais” depois
de escrever qual deles é o maior e menor se a diferença entre os dois
números for menor do que 1.0 / 100.

6. Altere agora o corpo do ciclo de modo a que leia apenas um double de
cada vez. Defina duas variáveis para registar o maior e menor valor
encontrados até agora. A cada passagem do ciclo, escreva no ecrã o valor
que foi inserido. Se este for o menor até agora, escreva “o menor até
agora” após o número. Se for o maior até agora, escreva “o maior até
agora” após o número.
7. Adicione uma unidade a cada double lido; isto é, insira valores como
10cm, 2.5in, 5ft ou 3.33m. Aceite quatro unidades: cm, m, in, ft.
Considere os fatores de conversão 1m == 100cm, 1in == 2.54cm, 1ft
== 12in. Leia o indicador da unidade numa string. Pode considerar 12
m (com um espaço entre o número e a unidade) equivalente a 12m (sem
espaço).
8. Rejeite valores sem unidades ou com representações não-definidas, como

j, jarda, metro, km, etc.

9. Mantenha um registo dos valores lidos (assim como o menor e o maior) e

o número de valores lidos. Quando o ciclo terminar, escreva para o ecrã o
menor, o maior, o número de valores lidos e a soma dos valores. Observe
que, para manter um registo da soma, é necessário decidir qual a unidade
a ser usada para essa soma. Use metros.
10. Guarde todos os valores inseridos (convertidos em metros) num vetor. No

final, escreva esses valores.
11. Antes de escrever os valores do vetor, ordene-os por ordem crescente.

4.9 Exercı́cios.
2. Se definirmos a mediana de uma série como ”o número para o qual

exatamente metade dos elementos da série vêm antes do mesmo e
metade vêm depois”, corrija o programa visto anteriormente de modo a
que imprima sempre uma mediana. Dica: Uma mediana não precisa ser
um elemento da sequência.
3. Leia uma sequência de valores double para um vetor. Pense em cada um

destes valores como a distância entre duas cidades ao longo de um
trajeto. Calcule e imprima a distância total (a soma de todas as
distâncias). Encontre e imprima a menor e maior distância entre duas
cidades vizinhas. Encontre e imprima a distância média entre duas
cidades vizinhas.

4.9 Exercı́cios.
4. Escreva um programa para um jogo de adivinhação de números. O

utilizador pensa num número entre 1 e 100 e o seu programa faz
perguntas para descobrir qual é o número (por exemplo, ”O número é
menor que 50?”). O programa deve ser capaz de identificar o número
depois de fazer no máximo sete perguntas. Dica: Use os operadores < e
<= e o comando if-else.
5. Escreva um programa que funcione como uma calculadora muito simples.

A sua calculadora deve ser capaz de lidar com as quatro operações
matemáticas básicas - adicionar, subtrair, multiplicar e dividir – aplicadas
a dois valores de entrada. O programa deve solicitar ao utilizador que
digite três argumentos: dois valores do tipo double e um carácter para
representar uma operação. Se os argumentos de entrada forem 35.6, 24.1
e ’+’, a saı́da do programa deve ser “A soma de 35.6 e 24.1 é 59.7”.

4.9 Exercı́cios.
6. Faça um vetor armazenar dez valores do tipo string ”zero”, ”um”, . . .

”nove”. Use este vetor num programa que converte um dı́gito no seu valor
correspondente por extenso. Por exemplo, a entrada 7 fornece a saı́da
sete. Faça com que o mesmo programa, usando o mesmo ciclo de
entrada, converta números por extenso nos dı́gitos correspondentes. Por
exemplo, a entrada sete fornece a saı́da 7.
7. Modifique a “mini-calculadora” do exercı́cio 5 para aceitar (apenas)

números de um dı́gito escritos como dı́gitos ou por extenso.

4.9 Exercı́cios.
8. Há um conto antigo em que o imperador queria agradecer ao inventor do

jogo de xadrez e lhe perguntou o que queria como recompensa. O
inventor pediu um grão de arroz para o primeiro quadrado, 2 para o
segundo, 4 para o terceiro e assim por diante, dobrando para cada um dos
64 quadrados. Isso pode parecer modesto, mas não havia arroz suficiente
no império! Escreva um programa para calcular quantos quadrados são
necessários para dar ao inventor pelo menos 1000 grãos de arroz, pelo
menos 1.000.000 de grãos de arroz e pelo menos 1.000.000.000 de grãos
de arroz. Será necessário um ciclo, e provavelmente um int para o
quadrado atual, um int para o número de grãos no quadrado atual e um
int para controlar os grãos em todos os quadrados anteriores. Sugerimos
que escreva para o monitor o valor de todas as variáveis para cada
iteração do ciclo de modo a que seja claro o que está a acontecer.

4.9 Exercı́cios.
9. Tente calcular o número de grãos de arroz que o inventor pediu no

exercı́cio 8. Você descobrirá que o número é tão grande que não cabe
num int ou num double. Observe o que acontece quando o número é
demasiado grande para ser representado de forma exata como um int e
como um double. Qual é o maior número de quadrados para o qual se
pode calcular o número exato de grãos usando um int? Qual é o maior
número de quadrados para o qual se pode calcular o número aproximado
de grãos usando um double?

4.9 Exercı́cios.
10. Escreva um programa que reproduza o jogo “Pedra, Papel, Tesoura”. Se

não estiver familiarizado com o jogo, faça uma pesquisa no Google. A
pesquisa é uma tarefa comum para programadores. Use uma instrução
switch para resolver este exercı́cio. Além disso, a máquina deve fornecer
respostas aleatórias (ou seja, selecionar a próxima pedra, papel ou tesoura
aleatoriamente). A aleatoriedade real é difı́cil de definir agora, e por isso,
basta construir um vetor com uma sequência de valores a ser usada como
”o próximo valor”. Se você criar o vetor no programa, ele reproduzirá
sempre o mesmo jogo, e por isso talvez seja boa ideia permitir que
utilizador insira alguns valores. Tente diferentes variações para tornar mais
difı́cil ao utilizador adivinhar qual movimento a máquina fará em seguida.

4.9 Exercı́cios.
11. Crie um programa para encontrar todos os números primos entre 1 e 100.
Uma maneira de fazer isso é escrever uma função que irá verificar se um
número é primo (isto é, ver se o número pode ser dividido por um número
primo menor que o próprio) usando um vetor de números primos
ordenados (de modo que se o vector é chamado de primos, primos [0] ==
2, primos [1] == 3, primos [2] == 5, etc.). De seguida, escreva um ciclo
que vai de 1 a 100, verifica cada número para ver se é primo e armazena
cada número primo encontrado num vetor. Escreva outro ciclo que lista os
primos encontrados. O resultado pode ser verificado comparando o vetor
de números primos com primos. Considere que 2 é o primeiro primo.
12. Modifique o programa descrito no exercı́cio anterior para receber um valor

de entrada max e depois encontre todos os números primos de 1 até max.

4.9 Exercı́cios.
13. Crie um programa para encontrar todos os números primos entre 1 e 100.
Existe um método clássico chamado de ”Crivo de Eratóstenes”. Procure
na internet como funciona este método e utilize-o no seu programa.
14. Modifique o programa descrito no exercı́cio anterior para receber um valor

de entrada max e, de seguida, encontre todos os números primos de 1 a
max.
15. Escreva um programa que obtenha um valor de entrada n e, em seguida,

encontre os primeiros n números primos.
16. Na secção “prática” foi escrito um programa que, dada uma série de
números, encontra o máximo e o mı́nimo desta série. O número que
aparece mais vezes numa sequência é chamado modo. Crie um programa
que encontre o modo de um conjunto de inteiros positivos.

4.9 Exercı́cios.
17. Escreva um programa que encontre o mı́nimo, o máximo e o modo de

uma sequência de strings.
18. Escreva um programa para resolver equações quadráticas que têm a

forma:
ax 2 + bx + c = 0
Se não conhecer a fórmula resolvente, procure na internet. Use variáveis
do tipo double para que utilizador insira os valores de a, b e c. Como
existem duas soluções para uma equação quadrática, produza as soluções
x1 e x2.

4.9 Exercı́cios.
19. Escreva um programa em que primeiro o utilizador insere conjunto de
pares de nome e valor, tais como Joe 17 e Barbara 22. Para cada par,
coloque o nome num vetor chamado nomes e o número num vetor
chamado pontos (em posições correspondentes, de modo que, se
nomes[7] == ”Joe”, pontos [7] == 17). Termine a entrada com a linha
“fim 0”. Verifique se cada nome é único e termine com uma mensagem de
erro se um nome for inserido duas vezes. Escreva todos os pares (nome,
pontuação), um por linha.
20. Modifique o programa do exercı́cio 19 de modo a que, quando for

fornecido um nome, o programa mostrará a pontuação ou “nome não
encontrado”.
21. Modifique o programa do exercı́cio 19 de modo a que, quando for

fornecido um inteiro, o programa mostrará todos os nomes com essa
pontuação ou “pontos não encontrados”.

Slides CPP Cap04 v1

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Slides CPP Cap04 v1

Enviado por

Direitos autorais:

Formatos disponíveis

Programação Aplicada: C++

Diogo Chambel Lopes

Atlântica, Instituto Universitário

Programação Aplicada: C++ Atlântica, Instituto Universitário

Programação Aplicada: C++ Atlântica, Instituto Universitário

4.2. Objetivos e ferramentas.

4.4. Comandos (statements).

4.8. Questões de revisão.

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ O input (dados de entrada) pode ter origem em diferentes fontes:

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Do ponto de vista da programação, os casos mais importantes são de ou

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ A abreviação I/O significa input/output.

▶ Neste caso, o output de uma determinada parte do programa é o input da

▶ Aqui, as partes de um programa são entidades como funções que

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Não é importante que um programa seja rápido, se produzir resultados

▶ Da mesma forma, se um programa estiver correto e for eficiente, poderá

▶ Em geral, os programas estão sujeitos a evolução para se adaptarem a

▶ A ferramenta principal que temos à nossa disposição para organizar um

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Abstração: Neste caso, os detalhes da implementação que não são

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Uma expressão computa um valor a partir de conjunto de operandos.

▶ Os nomes das variáveis também são expressões.

▶ Nos exemplos abaixo os valores literais 20 e 40 são usados para inicializar

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Deste modo que a expressão de atribuição é lida como: coloque 99 no

▶ É necessário distinguir entre o objeto usado no lado esquerdo de uma

Programação Aplicada: C++ Atlântica, Instituto Universitário

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Por exemplo, um programa de geometria pode utilizar o valor de π e um

▶ Obviamente, queremos utilizar nomes que indiquem o significado destas

▶ Da mesma forma também não queremos que os valores destas constantes

▶ Em C++, uma constante simbólica é tipo de objeto com nome associado

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Por exemplo, o valor de π pode ser definido de diferentes formas

▶ É preferı́vel definir π através de uma constante com o valor apropriado.

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Na definição de uma constante simbólica através de constexpr tem de ser

Programação Aplicada: C++ Atlântica, Instituto Universitário

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ As constantes do tipo const são muito comuns por duas razões:

1. A opção constexpr não estava presente no padrão C++98.

2. As constantes que não são conhecidas inicialmente, mas cujo valor

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Até agora utilizámos os operadores mais simples, no entanto, para

▶ A maioria dos operadores são convencionais, e serão apresentados mais

▶ Os operadores mais comuns estão listados no slide seguinte (lval é o

Programação Aplicada: C++ Atlântica, Instituto Universitário

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Um incremento pode ser expresso de pelo menos três formas diferentes:

▶ Os compiladores modernos tendem a gerar exatamente o mesmo código

▶ a∗ = scale tem o mesmo resultado de a = a ∗ scale.

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ Podemos combinar tipos diferentes na mesma expressão. Por exemplo:

▶ Neste caso, à primeira vista parece não estar definido se se trata da

▶ A divisão inteira descarta o resto da divisão: 5/2 é igual a 2.

▶ No caso da divisão de dois números reais (floating-point division):

▶ A regra para os tipos que apresentados até agora é que se um operador

Programação Aplicada: C++ Atlântica, Instituto Universitário

▶ As notações tipo(valor) e tipo{valor} significam: converter valor para