Slides CPP Cap03 v1

Programação Aplicada: C++
1 o Ano - 1 o Semestre
Diogo Chambel Lopes
Atlântica, Instituto Universitário
2023-2024
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.
Conteúdo dos slides adaptado do livro: Programming principles and practice
using C++, Bjarne Stroustrup, 2a edição, capı́tulo 3.

3. Objetos, tipos e valores.
3.1. Dados de entrada (input).
3.2. Variáveis.
3.3. Input e tipo de variável.
3.4. Operações e operadores.
3.5. Atribuição simples e inicialização.
3.6. Operadores compostos de atribuição.
3.7. Nomes.
3.8. Tipos e objetos.
3.9. Conversões entre tipos de dados (type safety ).

3.1 Dados de entrada (input).
▶ Ao contrário do programa Hello, World!, em geral um programa precisa
de dados de entrada (input).
▶ Para ler dados, é necessário reservar espaço na memória do computador

para os armazenar.
▶ Este espaço é chamado objeto e consiste numa região de memória

associado a um tipo de dados que aı́ podem ser guardados.
▶ Um objeto associado a um nome é uma variável.
▶ Um objeto pode ser visto como uma caixa em que se guardam valores do
tipo do objeto (exemplo: tipo inteiro, valor 42):

▶ Se a variável for do tipo string (sequência de caracteres), pode ser lida
com o código abaixo:
// ler e escrever um nome

#include<iostream>
using namespace std;
int main()
{
cout << "Insira o seu primeiro nome (seguido de ’enter’):\n";
string first_name; // variavel do tipo string
cin >> first_name; // ler string
cout << "Hello, " << first_name << "!\n";
}
▶ A primeira linha da função main() escreve uma mensagem no ecrã,

pedindo ao utilizador que escreva o seu primeiro nome.

▶ A linha abaixo reserva um espaço de memória para guardar uma variável
do tipo string e atribui-lhe o nome first name. Este tipo de instrução é
uma definição.
string first_name; // variavel do tipo string
▶ A linha seguinte lê uma sequência de caracteres a partir do teclado e

armazena-a nessa variável.
cin >> first_name; // ler string
▶ O nome cin refere-se ao standard input stream e pronuncia-se “c-in”

(character input).
▶ O operando do operador >> (get from) especifica onde vão ser

armazenados os dados.

▶ O computador aceita os dados inseridos na string até que seja premida a

tecla Enter (nova linha), e isto permite que o utilizador corrija os dados
que inseriu, apagando caracteres e inserindo outros, antes de pressionar
Enter.
▶ Uma vez inserida a string na variável first name, esta pode ser utilizada:
cout << "Hello, " << first_name << "!\n";
▶ A linha de código acima escreve a mensagem abaixo no ecrã e no final

muda para uma nova linha (\n).
Hello, Diogo!

▶ Apesar de ser uma má opção, a instrução cout acima também pode ser
escrita da seguinte forma:
cout << "Hello, ";

cout << first_name;
cout << "!\n";
▶ O texto que deverá aparecer no ecrã de forma literal é escrito entre aspas,
o que não acontece com o nome da variável first name.

3.2 Variáveis.
▶ Como foi visto anteriormente, um objeto associado a um nome é uma

variável que tem um tipo especı́fico (como int ou string) e
consequentemente tem também um conjunto de operações associadas.
▶ Por exemplo, as variáveis do tipo int podem ser multiplicadas usando o

operador ∗.
▶ Os dados que são colocados em variáveis são os valores da variável.
▶ Uma instrução que define uma variável é chamada definição, e uma

definição pode atribuir um valor inicial à variável.
string name = "Annemarie";

int number_of_steps = 39;

3.2 Variáveis.
▶ Não é permitido colocar valores de tipo errado numa variável:
string name2 = 39; // erro: 39 nao é uma string

int number_of_steps = "Annemarie"; // erro: "Annemarie" n~ao é um int
▶ O compilador verifica se os dados fornecidos para uma variável são do

tipo correto de acordo com a definição da variável.
▶ Em C++ existe um grande número de tipos de variáveis, no entanto, na
maioria dos casos são necessários apenas 5:
int number_of_steps = 39; // int para inteiros

double flying_time = 3.5; // double para numeros com parte decimal
char decimal_point = ’.’; // char para caracteres individuais
string name = "Annemarie"; // string para sequencias de caracteres
bool tap_on = true; // bool para variáveis logicas

3.2 Variáveis.
▶ A origem do nome double vem de double-precision floating point, que

representa a aproximação dum computador aos números reais.
▶ Cada um destes tipos de variáveis está associado a um tipo de literal
(valor):
39 // int: um inteiro
3.5 // double: numero com parte decimal
’.’ // char: carácter individual delimitado por plicas ’ ’
"Annemarie" // string: sequencia de caracteres delimitados por " "
true // bool: true ou false

3.3 Input e tipo de variável.
▶ A operação de input >> (get from) é sensı́vel ao tipo de dados, ou seja,
lê os dados de entrada de acordo com o tipo de variável que vai
armazenar os dados. Por exemplo:
// ler nome e idade

#include<iostream>
int main()
{
cout << "Insira o seu primeiro nome e idade\n";
string first_name = "???";
int age = -1;
cin >> first_name >> age; // ler string seguida de inteiro
cout << "Hello, " << first_name << " (idade " << age << ")\n";
}

▶ Se o utilizador inserir no teclado: Carlos 22, o operador >> lê Carlos para
a variável first name e 22 para a variável age, produzindo a seguinte
mensagem de saı́da:
Hello, Carlos (age 22)
▶ Isto acontece uma vez que por convenção as variáveis do tipo string
terminam com um dos caracteres: espaço, nova linha (Enter) ou tab.
▶ Noutros casos o carácter espaço é ignorado pelo operador >>.
▶ Qualquer número de espaços em branco antes de um número a ser lido

pelo operador >> é ignorado.
▶ Se o utilizador escrever 22 Carlos, 22 será o valor de first name uma vez

que 22 também é uma sequência de caracteres.
▶ Por outro lado, Carlos não é um inteiro e por isso não será lido.

▶ A mensagem de saı́da do código, no lugar do valor de age colocará algum
número aleatório como −96739 ou 0, caso não seja definido um valor
inicial para a variável age.
▶ Assim sendo, é preferı́vel inicializar a variável age para que tenha um valor
previsı́vel se a entrada de dados falhar.
▶ Da mesma forma que podemos ler vários valores a partir de uma

instrução cin, também podemos escrever vários valores para a saı́da com
uma instrução cout.
▶ Os operadores << e >> são sensı́veis ao tipo de variável.
▶ Uma string lida com >> é terminada por defeito por um espaço, ou seja,
é lida apenas uma palavra.
▶ Por vezes queremos ler mais do que uma palavra para a mesma string e
existem várias formas de fazer isto.
▶ Por exemplo, um nome composto por duas palavras pode ser armazenado
em duas variáveis do tipo string:
#include<iostream>
// ler 2 nomes
int main()
{
cout << "Insira o seu primeiro e segundo nomes\n";
string first;
string second;
cin >> first >> second; // ler duas strings
cout << "Bom dia, " << first <<" "<< second << "\n";
}
▶ Neste caso, para escrever o nome completo para o ecrã, será necessário
inserir um espaço entre as duas strings.
Exercı́cio (try this)
▶ Corra o código do anterior que lê o nome e a idade.
▶ Modifique o código para que escreva a idade em meses lendo a idade em

anos e usando o operador ∗.
▶ Use uma variável do tipo double para a idade de modo a permitir valores
não-inteiros, como 5.5 anos.

3.4 Operações e operadores.
▶ Para além de especificar que valores que podem ser armazenados numa
variável, o tipo de variável também determina quais são as operações que
lhe podem ser aplicadas e o seu significado. Por exemplo:
int count;
cin >> count; // >> armazena um inteiro em count
string name;
cin >> name; // >> armazena uma string em name
int c2 = count+2; // + adiciona inteiros

string s2 = name + " Jr. "; // + concatena caracteres
int c3 = count-2; // - subtrai inteiros

string s3 = name - " Jr. "; // erro: - nao definido para strings
▶ Erro aqui significa que o compilador rejeita um programa que tente

subtrair strings.

▶ O compilador sabe quais são as operações que são permitidas para cada
variável e desta forma pode prevenir muitos erros.
▶ No entanto, o compilador não sabe quais são as operações e valores que

fazem sentido do ponto de vista do algoritmo que está a ser programado,
e aceitará operações legais mesmo que originem resultados absurdos.
▶ Por exemplo, poderá ser óbvio que uma idade não pode ser negativa, mas
o computador não sabe isso.
int age = -100;
▶ A tabela seguinte mostra uma lista de operadores úteis associados a tipos

de variáveis comuns.


▶ Para variáveis do tipo double, os operadores aritméticos habituais têm o
significado esperado:
// exemplos de operadores
#include<iostream>
#include<cmath> // sqrt()
int main()
{
cout << "Insira um valor do tipo double: ";
double n;
cin >> n;
cout << "n == " << n
<< "\nn+1 == " << n+1
<< "\ntriplo de n == " << 3*n
<< "\ndobro de n == " << n+n
<< "\nn ao quadrado == " << n*n
<< "\nmetade de n == " << n/2
<< "\nraiz quadrada de n == " << sqrt(n)
<< endl; // alternativa para nova linha
}

▶ Nem todas as operações com variáveis do tipo double que poderemos

necessitar estão disponı́veis na forma de um operador.
▶ Por exemplo, a raiz quadrada de um número é representado por uma

função com nome (named function).
▶ A função sqrt() é usada para calcular a raiz quadrada, e está incluı́da na

biblioteca padrão do C++.

▶ Corra o programa anterior.
▶ Modifique-o para que leia um int em vez de um double.
▶ Experimente também outras operações.
▶ Note que para o tipo int / é a divisão inteira e % é o resto da divisão

inteira (remainder, modulo), de modo que 5/2 é igual a 2 (e não 2.5 ou
3) e 5%2 é igual a 1.

▶ As strings têm menos operadores, mas estes têm de ser usados da forma
convencionada. Por exemplo:
// ler primeiro e segundo nomes
#include<iostream>
int main()
{
cout << "Insira os seus primeiro e segundo nomes\n";
string first;
string second;
string name = first + ’ ’ + second; // concatenar
cout << "Hello, " << name << ’\n’;
}
▶ Para strings + significa concatenação, ou seja, se s1 e s2 forem strings,
s1 + s2 é uma string em que os caracteres de s1 são seguidos pelos
caracteres de s2.
▶ Por exemplo, se s1==“Hello” e s2==“World”, então s1+s2=“HelloWorld”.
▶ A comparação de strings poderá ser bastante útil (if no capı́tulo 4):
// ler e comparar nomes
#include<iostream>
int main()
{
cout << "Insira dois nomes\n";
string first;
string second;
if (first == second) cout << "nomes repetidos\n";
if (first < second)
cout << first << " alfabeticamente antes de " << second <<’\n’;
if (first > second)
cout << first << " alfabeticamente depois de " << second <<’\n’;
}
3.5 Atribuição simples e inicialização.
▶ De certa forma, o operador = é o operador mais interessante, uma vez
que permite atribuir um novo valor a uma variável. Por exemplo:

▶ O último exemplo da figura anterior mostra uma particularidade deste

operador: = em C++ não significa “igual a” uma vez que a não é igual a
a + 7.
▶ Na verdade, = é o operador de atribuição (assignment) e atribui um

novo valor a uma variável.
▶ Se o valor inicial de a for 4, depois de executada a instrução a = a + 7, o

valor de a será 11.

▶ Exemplos do operador = com strings:

▶ Nos exemplos do slide anterior são mostradas duas operações que usam a
mesma notação = em C++, que são semelhantes mas logicamente
distintas:
▶ Inicialização (na declaração da variável): aplicada a uma variável

sem valor atribuı́do.
▶ Atribuição de um novo valor: substitui um valor existente da

variável.

Exemplo: deteção de palavras repetidas
▶ O programa abaixo deteta palavras adjacentes repetidas numa sequência
mas não informa da sua localização, e é incluı́do em muitos corretores
ortográficos:
#include<iostream>
int main()
{
string previous = " "; // palavra anterior, variavel inicializada.
string current; // palavra atual
while (cin>>current) { // ler sequencia de palavras
if (previous == current) // verificar: atual == anterior
cout << "palavra repetida: " << current << ’\n’;
previous = current;
}
}

▶ Definição da variável que irá conter cada palavra inserida pelo utilizador:
string current;
▶ Instrução que lê cada palavra inserida pelo utilizador:
while (cin>>current)
▶ A estrutura while que é apresentada no capı́tulo 4, faz com que o

programa repita as instruções entre chavetas, enquanto a condição entre
parêntesis for verdadeira.
▶ O ciclo é interrompido inserindo um carácter EOF (end of file): Ctrl+z

seguido de Enter (return) em Windows ou Ctrl+d em linux.

▶ Se duas palavras seguidas forem iguais:
if (previous == current) // verificar: atual == anterior

cout << "palavra repetida: " << current << ’\n’;
▶ Para que a última palavra que foi inserida fique disponı́vel para ser
comparada com a seguinte é necessário:
previous = current;
▶ Desta forma são tratados todos os casos exceto a primeira palavra que é
inserida, uma vez que não há uma palavra anterior para comparação.
▶ Esta situação é resolvida pela inicialização com um espaço da variável
previous na sua definição, uma vez que o operador >> não lê espaços.
string previous = " "; // inicializar variavel

▶ Teste o programa que deteta palavras repetidas com a frase:

She she laughed He He He because what he did did not look very very
good good
▶ Quantas palavras repetidas foram detetadas?
▶ Qual é a definição de palavra usada aqui?
▶ Qual é a definição de palavra repetida? (Por exemplo, She she é uma

repetição?)

3.6 Operadores compostos de atribuição.
▶ A operação de incrementar (adicionar 1) uma variável é comum em
programação e em C++ existe uma sintaxe especial para esta operação.
▶ Por exemplo, as instruções seguintes são equivalentes:
++counter <=> counter = counter + 1
▶ Existem muitas outras forma de alterar o valor de uma variável em função

do seu valor atual.
▶ Por exemplo, para somar, subtrair ou multiplicar uma variável por uma
constante:
a += 7 <=> a = a+7
b -= 9 <=> b = b-9
c *= 2 <=> c = c*2

▶ Em geral, para qualquer operador binário oper: a oper = b significa

a = a oper b.
▶ Para começar, podemos considerar os operadores +=, -=, *=, /=, e

%=.
▶ Os operadores *= e /= podem ser vistos como fatores de escala.

▶ O exemplo dado anteriormente para deteção de palavras repetidas pode
ser melhorado se incluirmos um contador que nos dirá onde ocorreu a
palavra repetida na sequência de palavras introduzida pelo utilizador.
#include<iostream>
int main()
{
int number_of_words = 0;
string previous = " "; // inicializar variavel
string current;
while (cin>>current) {
++number_of_words; // incrementar contador de palavras
if (previous == current)
cout << "palavra numero: " << number_of_words
<< " repetida: " << current << ’\n’;
previous = current;
}
}
▶ O contador é inicializado a 0, e de cada vez que é inserida uma nova
palavra, o contador é incrementado:
++number_of_words;
▶ Desta forma, a primeira palavra é a nº1, a segunda palavra é a nº2, e
assim sucessivamente.
▶ A mesma instrução poderia ser escrita como:

number_of_words += 1;
ou
number_of_words = number_of_words+1;
▶ Aqui reaproveitámos o código existente da secção anterior e aplicámos

algumas modificações. Esta é uma técnica comum que deve ser aplicada
quando for possı́vel (exceto em avaliações desta disciplina).

3.7 Nomes.
▶ Em geral devemos dar nomes às variáveis de modo a que nos lembremos
do seu significado e para que possamos utilizá-las noutras partes de um
programa.
▶ Em C++, um nome começa com uma letra e contém apenas letras,

dı́gitos, e underscores. Exemplos:
x
number_of_elements
Fourier_transform
z2
Polygon
▶ Os exemplos seguintes não são aceites pelo compilador como nomes:

2x // a name must start with a letter
time$to$market // $ is not a letter, digit, or underscore
Start menu // space is not a letter, digit, or underscore

3.7 Nomes.
▶ Por vezes aparecem nomes que começam com underscore como foo, mas
estes estão reservados para o sistema e não podem ser utilizados.
▶ Os nomes são sensı́veis a letras maiúsculas e minúsculas, ou seja, x e X

são nomes diferentes.
▶ O programa seguinte contém pelo menos quatro erros:
#include<iostream>
int Main()
{
STRING s = "Adeus, mundo cruel! ";
cOut << S << ’\n’;
}

3.7 Nomes.
▶ Em geral não é boa ideia definir nomes que diferem apenas numa letra,
sendo minúscula num nome e maiúscula no outro, como em one e One, o
que não confundirá o compilador, mas pode facilmente confundir o
programador.
▶ Exercı́cio (try this)
▶ Compile o programa do slide anterior e examine as mensagens de

erro.
▶ O compilador encontrou todos os erros? Que problemas são
sugeridos pelo compilador?
▶ O compilador confundiu-se e diagnosticou mais do que 4 erros?
▶ Remova os erros um a um, e veja como vão mudando as mensagens
de erro.

3.7 Nomes.
▶ A linguagem C++ reserva cerca de 85 nomes como palavras-chave

(keywords), que estão listadas no apêndice A.3.1. do livro (slide seguinte)
e não podem ser usados como nomes de variáveis, tipos, funções, etc.
Por exemplo:
int if = 7; // error: if is a keyword
▶ Os nomes escolhidos para as variáveis devem ter algum significado de

modo a que ajudem quem os ler a compreender o programa, incluindo o
programador que escreveu o programa.

3.7 Nomes.
▶ Nomes reservados:

3.7 Nomes.
▶ Abreviações e acrónimos devem ser evitados. Exemplos:
mtbf
TLA
myw
NBV
▶ Nomes curtos como x e i tem significado quando usados em

determinados contextos: x poderá ser uma variável local e i poderá ser o
ı́ndice de um ciclo (capı́tulo 4).
▶ Os nomes também não devem ser demasiado longos, uma vez que são
difı́ceis de escrever, tornam as linhas demasiado longas e são difı́ceis de
ler rapidamente.

3.7 Nomes.
▶ Bons exemplos de nomes:
partial_sum
element_count
stable_partition
▶ Exemplos de nomes que provavelmente são demasiado longos:
the_number_of_elements
remaining_free_slots_in_symbol_table
▶ Em geral, no livro são usados underscores para separar palavras num

nome como element count, em vez de alternativas como
elementCount.
▶ Os caracteres 0 (zero), o (O minúsculo), O (o maiúsculo), 1 (um), I (i

maiúsculo), e l (L minúsculo) são particularmente fáceis de confundir.

3.8 Tipos e objetos.
▶ A noção de tipo é central em C++ e na maioria das linguagens de
programação:
▶ Um tipo define um conjunto de valores e de operações que é
possı́vel associar a um objeto.
▶ Um objeto é uma região de memória que contém um valor de
determinado tipo.
▶ Um valor é um conjunto de dados armazenados em memória que
são interpretados de acordo com um tipo.
▶ Uma variável é um objeto com um nome associado.
▶ Uma declaração é uma instrução que dá um nome a um objeto.
▶ Uma definição é uma declaração que reserva memória para um
objeto.

▶ Um objeto do tipo int pode conter números inteiros, como 7, 42, ou
–399.
▶ Um objeto do tipo string pode conter sequências de caracteres, como

“Interoperability”, “tokens: !@#$%ˆ&*”, ou “Old MacDonald had a farm”.
▶ Graficamente:

▶ A representação de uma string é mais complicada no que a de um int

uma vez que uma string guarda o número de caracteres da mesma.
▶ Todos os objetos do tipo int tem o mesmo tamanho, ou seja, o

compilador reserva a mesma quantidade de memória para cada int.
▶ Num computador tı́pico, um int ocupa 4 bytes (32 bits) de memória.
▶ Da mesma forma, os objetos do tipo bool, char, e double também têm

um tamanho fixo.

▶ Tipicamente um computador usa um byte (8 bits) para um bool ou char

e 8 bytes para um double.
▶ A mesma sequência de bits em memória tem um significado diferente

consoante o tipo de dados do objeto.
▶ Exemplo: A sequência de bits da figura pode ser lida como um int (120)
ou como um char (’x’, considerando apenas os últimos 8).
▶ Um bit é uma unidade de memória do computador que pode conter o

valor 0 ou 1.

3.9 Conversões entre tipos de dados (type safety ).
▶ É atribuı́do um tipo a todos os objetos quando são definidos.
▶ Um programa, ou parte de um programa, é seguro quanto ao tipo de
dados (type-safe) quando os objetos são usados apenas de acordo com as
regras que se aplicam ao seu tipo.
▶ Infelizmente, existem formas de executar operações que não são seguras
deste ponto de vista.
▶ Por exemplo, usar uma variável antes de esta ter sido inicializada não é
considerado seguro (type-safe):
#include<iostream>
int main()
{
double x; // o valor de x nao foi definido
double y = x; // o valor de y nao foi definido
double z = 2.0+x; // o valor de z nao foi definido
}
▶ As variáveis devem ser sempre inicializadas, exceto em alguns casos

especiais, como por exemplo uma variável que vai receber dados do
utilizador.
▶ No entanto, inicializar sempre as variáveis é uma boa prática que poderá

evitar problemas.
▶ Infelizmente, um compilador de C++ não pode garantir que o programa é

completamente type-safe, mas podemos evitar violações da type-safety
com uma combinação de boas práticas de programação e verificação
(run-time checks).

Conversões seguras
▶ Na secção 3.4 foi visto que não podemos adicionar variáveis do tipo char
ou comparar um double com um int, no entanto, o C++ permite uma
forma indireta de fazer ambos.
▶ Quando necessário, um char pode ser convertido para um int e um int

pode ser convertido para um double. Por exemplo:
char c = ’x’;
int i1 = c;
int i2 = ’x’;
▶ Neste exemplo é atribuı́do o valor 120 a i1 e a i2, que corresponde ao

valor inteiro do carácter ’x’ em ASCII (8 bits).
▶ Esta é uma forma simples e segura de obter a representação numérica de

um carácter.

▶ Esta conversão de char para int é segura uma vez que não é perdida
nenhuma informação, ou seja, podemos converter de novo para char e
voltamos ao valor original.
char c2 = i1;
cout << c << ’ << i1 << ’ << c2 << ’\n’;
▶ Resultado:
x 120 x
▶ Neste sentido, de que um valor é sempre convertido para um valor igual,
ou no caso do double para a melhor aproximação de um valor igual, as
seguintes conversões são seguras:
bool to char
bool to int
bool to double
char to int
char to double
int to double
▶ A conversão de tipo mais útil é de int para double uma vez que permite
misturar ints e doubles na mesma expressão.
double d1 = 2.3;
double d2 = d1+2; // 2 convertido para 2.0 antes da soma
if (d1 < 0) // 0 convertido para 0.0 antes da comparacao
cout << "d1 negativo";

Conversões inseguras
▶ Infelizmente, o C++ também permite conversões de tipos que são
inseguras, o que significa que ao reverter a conversão não se obtém o
valor original. Por exemplo:
#include<iostream>
int main()
{
int a = 20000;
char c = a; // tentativa de colocar um grande int num pequeno char
int b = c;
if (a != b) // != significa nao-igual
cout << "oops!: " << a << "!=" << b << ’\n’;
else
cout << "existem grandes caracteres!\n";
}

▶ Estas conversões são redutoras, uma vez que colocam um valor num
objeto que poderá ser demasiado pequeno para o conter.
▶ Infelizmente, a maioria dos compiladores não produz um aviso sobre a

inicialização insegura de um char com um int.
▶ Neste caso, o problema é que em memória um int é tipicamente maior do

que um char, e consequentemente o valor do int poderá não ter
correspondência como um char.
▶ Corra o código anterior para ver o resultado obtido para b no seu

computador: 32 é um resultado comum.

▶ Experimente também o código seguinte, e verifique que muitos valores de
entrada produzem valores de saı́da que não são razoáveis.
#include<iostream>
int main()
{
double d = 0;
while (cin>>d) { // repetir os comandos abaixo
// enquanto forem inseridos numeros
int i = d; // tentativa de colocar um double num int
char c = i; // tentativa de colocar um int num char
int i2 = c; // obter o valor inteiro de um caracter
cout << "d==" << d // o double original
<< " i=="<< i // convertido para int
<< " i2==" << i2 // valor int do char
<< " char(" << c << ")\n"; // o char
}
}
▶ Todas as conversões abaixo são aceites pelo compilador, apesar de serem

inseguras.
double to int
double to char
double to bool
int to char
int to bool
char to bool
▶ Estas conversões não são seguras no sentido em que o valor armazenado

pode ser diferente do valor atribuı́do.

▶ Corra o programa anterior com vários valores de input. Tente valores

baixos (2 e 3...); valores altos (maiores do que 127, maiores do que 1000);
valores negativos; 56; 89; 128; valores não-inteiros (56.9 e 56.2 ...).
▶ Para além de mostrar como são feitos as conversões de para int e de int
para char no seu computador, este programa mostra mostra qual o
carácter (se algum) o seu computador produz em correspondência a um
determinado valor inteiro.

▶ Por vezes o programador pode não se aperceber de que está a ocorrer
uma conversão insegura. Por exemplo:
double x = 2.7;
// lots of code
int y = x; // y becomes 2
▶ Neste caso quando y é definido o programador pode ter esquecido que x é

do tipo double, é a conversão de double para int trunca a parte decimal
(arredonda sempre para baixo).
▶ As conversões de int para char não têm problemas de truncatura, uma

vez que nem int nem char podem representar uma fração de um número
inteiro.
▶ No entanto, um char apenas pode conter valores muito baixos de

números inteiros.
▶ Num PC, um char ocupa 1 byte enquanto um int ocupa 4 bytes.
▶ Por exemplo:
int a = 1000;
char b = a; // b becomes -24 (on some machines)
▶ Nem todos os valores do tipo int têm valores equivalentes do tipo char, o
que varia entre implementações.
▶ Num PC os valores de char estão no intervalo [–128:127], mas apenas

podem ser usados valores do intervalo [0:127]. Diferentes computadores
têm intervalos de valores diferentes, como [0:255].

▶ A razão da existência de conversões redutoras em C++ é histórica e tem
origem na linguagem C em este tipo de conversões era muito utilizado.
▶ Muitos compiladores produzem avisos quando detetam conversões

redutoras.
▶ O C++11 introduziu uma notação de inicialização que não permite

conversões redutoras.
▶ Por exemplo, os exemplos anteriores podem ser reescritos usando {} em

vez de =.
double x {2.7}; // OK
int y {x}; // error: double -> int might narrow
int a {1000}; // OK
char b {a}; // error: int -> char might narrow

3.10 Questões de revisão.
1. Que operador é utilizado para ler um valor e armazená-lo numa variável?
2. Que duas linhas de código são utilizadas se se pretender que o utilizador

insira um valor inteiro numa variável chamada number?
3. Para que serve o carácter \n?

▶ O operador >>, que é usado com a instrução cin.



▶ int number;
cin >> number;


▶ int number;
cin >> number;
▶ \n é um carácter especial que significa nova linha (mudança de

linha).

4. O que termina o input (entrada de dados) de uma string?
5. O que termina o input de um inteiro?
6. Como se poderia escrever o código abaixo em apenas uma linha?

cout << ”Hello, ”;
cout << first name;
cout << ”!\n”;

▶ Por convenção, as strings são terminadas por um dos seguintes

caracteres: espaço, nova linha (newline) ou tab.

cout << first name;
cout << ”!\n”;


▶ O operador >> aplicado a cin lê os dados de input enquanto façam

sentido para definir um int. Termina se forem inseridas letras,
espaços, pontos, vı́rgulas, etc.

cout << first name;
cout << ”!\n”;


▶ O operador >> aplicado a cin lê os dados de input enquanto façam

sentido para definir um int. Termina se forem inseridas letras,
espaços, pontos, vı́rgulas, etc.

cout << first name;
cout << ”!\n”;
▶ cout << ”Hello, ”<< first name << ”!\n”;
7. O que é um objeto?
8. O que é um (valor) literal?
9. Que tipos de (valores) literais existem?
10. O que é uma variável?

▶ É uma região de memória associada a um tipo de dados.

▶ É um valor constante que pode ser de qualquer um dos tipos de

dados básicos.


dados básicos.
▶ Os tipos mais usados são: int, double, char, string, bool.


dados básicos.
▶ Os tipos mais usados são: int, double, char, string, bool.
▶ É um objeto com um nome associado.

11. Que unidades usamos para medir o tamanho de entidades armazenadas
em memória, como ints e strings?
12. Quais são os tamanhos tı́picos dos objetos dos tipos char, int, e double?
13. Qual é a diferença entre = e ==?

▶ bits e bytes (1 byte == 8 bits).

▶ Tipicamente: int - 4 bytes (32 bits); bool - 1 byte (8 bits); char -

1 byte (8 bits); double - 8 bytes (64 bits).

▶ Tipicamente: int - 4 bytes (32 bits); bool - 1 byte (8 bits); char -

1 byte (8 bits); double - 8 bytes (64 bits).
▶ = é o operador de atribuição simples.

== (igual a) é um operador de comparação de dois valores.

14. O que é uma definição?
15. O que é uma inicialização e o que a distingue de uma atribuição?
16. O que uma concatenação de uma string e como funciona em C++?

▶ É uma instrução que introduz um novo nome no programa e reserva

memória para a respetiva variável.


▶ Ambas usam o operador =.



▶ Inicialização: dar um valor inicial a uma variável.



▶ Atribuição: dar um novo valor a uma variável.



▶ Atribuição: dar um novo valor a uma variável.
▶ Consiste em juntar palavras com o operador + aplicado a dados do

tipo string.

17. Quais dos seguintes nomes são legais em C++? Se algum dos nomes não
for legal, explique porquê? “This little pig”, “This 1 is fine”,
“2 For 1 special”, “latest thing”, “the $12 method”, “ this is ok”,
“MiniMineMine”, “number”, “correct?”.
18. Dê cinco exemplos de nomes que são legais mas que não devem ser
usados, para não causar confusão.

dı́gitos, e underscores. Os espaços não são permitidos.

▶ Nomes começados por underscore, que apesar de serem aceites pelo
compilador estão reservados para o sistema.

▶ Nomes que diferem entre si apenas por letras maiúsculas e
minúsculas.

minúsculas.
▶ Abreviaturas e acrónimos (siglas).

minúsculas.
▶ Abreviaturas e acrónimos (siglas).
▶ Nomes demasiado curtos ou demasiados longos.
19. O que é a segurança do tipo de dados (type safety) e por que é
importante?
20. A conversão de double para int pode não ser vantajosa. Porquê?
21. Defina uma regra para decidir se uma conversão entre tipos de dados é
segura ou não.

importante?
▶ Um programa, ou parte de um programa, é seguro quanto ao tipo
de dados (type-safe) quando os objetos são usados apenas de
acordo com as regras que se aplicam ao seu tipo.
segura ou não.

importante?
▶ A parte decimal dos valores do tipo double são truncados quando é
feita a conversão para int.
segura ou não.

importante?
▶ A parte decimal dos valores do tipo double são truncados quando é
feita a conversão para int.
segura ou não.
▶ Uma conversão entre tipos de dados é segura se não é perdida
nenhuma informação, ou seja, podemos converter de novo para o
tipo de dados original e voltar ao valor original.
3.11 Exercı́cios.
2. Escreva um programa em C++ que converta de milhas para quilómetros.

O programa deverá indicar ao utilizador que deve introduzir um número
de milhas. 1 milha corresponde a 1609 metros.
3. Escreva um programa que não calcule nada, mas que declare várias
variáveis com nomes legais e ilegais (como int double = 0;), para que
possa avaliar como o compilador reage.
4. Escreva um programa que peça ao utilizador para inserir dois valores

inteiros. Armazene esses valores em variáveis do tipo int denominadas
val1 e val2. O programa deverá determinar o menor, o maior, a soma, a
diferença, o produto e o quociente destes valores, escrevendo os
resultados no monitor.

3.11 Exercı́cios.
5. Modifique o programa do exercı́cio anterior para solicitar ao utilizador que
insira valores reais, armazenando-os em variáveis do tipo double.
Compare os resultados dos dois programas para alguns dados de input à
sua escolha. Os resultados são os mesmos? Deveriam ser? Qual é a
diferença?
6. Escreva um programa que peça ao utilizador que insira três valores

inteiros e que de seguida escreva no monitor os valores por ordem
crescente, separados por vı́rgulas. Assim, se o utilizador inserir os valores
10 4 6, a saı́da deve ser 4, 6, 10. Se dois valores forem iguais, deverão ser
ordenados juntos. Se os dados de entrada forem 4 5 4; o resultado deverá
ser 4, 4, 5.
7. Repita o exercı́cio 6, mas com três valores do tipo string. Se o utilizador

inserir os valores Steinbeck, Hemingway, Fitzgerald, o resultado deverá ser
Fitzgerald, Hemingway, Steinbeck.

3.11 Exercı́cios.
8. Escreva um programa para testar um valor inteiro e determinar se é par

ou ı́mpar. Certifique-se de que os dados de saı́da são apresentados de
forma clara e completa, por exemplo: O número 4 é um número par.
Dica: veja para que serve o operador %.
9. Escreva um programa que converta números inseridos por extenso como

“zero” e “dois” em dı́gitos, como 0 e 2. Quando o utilizador insere um
número por palavras, o programa deve escrever o dı́gito correspondente.
O programa deverá reconhecer os valores 0, 1, 2, 3 e 4 (por extenso, sem
acentos) e se o utilizador inserir algo que não é reconhecido, o programa
deverá produzir uma mensagem correspondente.

3.11 Exercı́cios.
10. Escreva um programa que receba uma operação seguida por dois
operandos e produza o resultado correspondente. Por exemplo:
+ 100 3.14
*45
Leia a operação numa string chamada oper e utilize um comando if para
determinar a operação que o utilizador deseja, por exemplo:
if (oper == ”+”).
Armazene os operandos em variáveis do tipo double. Implemente a rotina
para as operações +, -, *, /.
11. Escreva um programa que peça ao utilizador para inserir um certo número
de moedas de diferentes valores (1 cêntimo, 2 cêntimos, 5 cêntimos, 10
cêntimos, 20 cêntimos, 50 cêntimos, 1 euro, 2 euros). O programa deverá
escrever algo como:
▶ Você tem 23 moedas de 1 cêntimo.
▶ Você tem 17 moedas de 20 cêntimos.
▶ O valor de total das suas moedas é de 1.25= C.
Escreva os resultados de forma correta: euro ou euros consoante o caso.

Slides CPP Cap03 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 Cap03 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

3.3. Input e tipo de variável.

3.4. Operações e operadores.

3.5. Atribuição simples e inicialização.

3.6. Operadores compostos de atribuição.

3.8. Tipos e objetos.

3.9. Conversões entre tipos de dados (type safety ).

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

▶ Para ler dados, é necessário reservar espaço na memória do computador

▶ Este espaço é chamado objeto e consiste numa região de memória

▶ Um objeto associado a um nome é uma variável.

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

// ler e escrever um nome

▶ A primeira linha da função main() escreve uma mensagem no ecrã,

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

string first_name; // variavel do tipo string

▶ A linha seguinte lê uma sequência de caracteres a partir do teclado e

cin >> first_name; // ler string

▶ O nome cin refere-se ao standard input stream e pronuncia-se “c-in”

▶ O operando do operador >> (get from) especifica onde vão ser

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

▶ O computador aceita os dados inseridos na string até que seja premida a

cout << "Hello, " << first_name << "!\n";

▶ A linha de código acima escreve a mensagem abaixo no ecrã e no final

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

cout << "Hello, ";

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

▶ Como foi visto anteriormente, um objeto associado a um nome é uma

▶ Por exemplo, as variáveis do tipo int podem ser multiplicadas usando o

▶ Os dados que são colocados em variáveis são os valores da variável.

▶ Uma instrução que define uma variável é chamada definição, e uma

string name = "Annemarie";

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

string name2 = 39; // erro: 39 nao é uma string

▶ O compilador verifica se os dados fornecidos para uma variável são do

int number_of_steps = 39; // int para inteiros

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

▶ A origem do nome double vem de double-precision floating point, que

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

// ler nome e idade

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

Hello, Carlos (age 22)

▶ Noutros casos o carácter espaço é ignorado pelo operador >>.

▶ Qualquer número de espaços em branco antes de um número a ser lido

▶ Se o utilizador escrever 22 Carlos, 22 será o valor de first name uma vez

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

▶ Da mesma forma que podemos ler vários valores a partir de uma

▶ Os operadores << e >> são sensı́veis ao tipo de variável.

Exercı́cio (try this)

▶ Corra o código do anterior que lê o nome e a idade.

▶ Modifique o código para que escreva a idade em meses lendo a idade em

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

int c2 = count+2; // + adiciona inteiros

int c3 = count-2; // - subtrai inteiros

▶ Erro aqui significa que o compilador rejeita um programa que tente

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

▶ No entanto, o compilador não sabe quais são as operações e valores que

int age = -100;

▶ A tabela seguinte mostra uma lista de operadores úteis associados a tipos