Tipos Numéricos em C++

Prévia do material em texto

ESTUDO	
  DIRIGIDO	
  
CIÊNCIA	
  /	
  ENGENHARIA	
  DA	
  COMPUTAÇÃO	
  
Técnicas	
  de	
  Programação	
  I	
  
Olegário	
  Correa	
  da	
  Silva	
  Neto 
	
  
	
  
OBJETIVO	
   Revisar	
  as	
  práticas	
  de	
  programação.	
  
CONTEÚDO	
   Considere	
  os	
  seguintes	
  tipos	
  de	
  dados	
  numéricos	
  (C++):	
  
Tipos	
  inteiros:	
  
bool	
  
char	
  
short	
  int	
  
int	
  
long	
  int	
  
unsigned	
  char	
  
unsigned	
  short	
  int	
  
unsigned	
  int	
  
unsigned	
  long	
  int	
  
Tipos	
  ponto	
  flutuante:	
  
float	
  
double	
  
long	
  double	
  
Compile	
  e	
  execute	
  o	
  programa	
  abaixo	
  para	
  testar	
  os	
  limites	
  de	
  cada	
  tipo	
  numérico:	
  
#include <iostream> 
#include <limits> 
#include <cstdlib> 
using namespace std; 
int main(void){ 
 //Declaracao de um objeto numeric_limits, que e iniciado automaticamente (int) 
 numeric_limits<int> limitesInt; 
 //Declaracao de um objeto numeric_limits, que e iniciado automaticamente (unsigned int) 
 numeric_limits<unsigned int> limitesIntSemSinal; 
 
 //Impressao dos limites na tela 
 cout<<"Inteiros"<<endl; 
 cout<<"Tamanho: "<<sizeof(int)<<" Bytes"<<endl; 
 cout<<"Valor inteiro maximo: "<<limitesInt.max()<< endl; 
 cout<<"Valor inteiro minimo: "<<limitesInt.min()<< endl; 
 cout<<"Inteiros sem sinal"<< endl; 
 cout<<"Tamanho: "<<sizeof(unsigned int)<<" Bytes"<<endl; 
 cout<<"Valor inteiro maximo: "<<limitesIntSemSinal.max()<<endl; 
 cout<<"Valor inteiro minimo: "<<limitesIntSemSinal.min()<< endl; 
 return EXIT_SUCCESS; 
} 
Ao	
  dividirmos	
  (/)	
  dois	
  operandos	
  do	
  mesmo	
  tipo,	
  o	
  resultado	
  será do	
  mesmo	
  tipo.	
  Porém,	
  qual	
  seria	
  
o	
   tipo	
   de	
   resultado	
   caso	
   o	
   primeiro	
   operando	
   seja	
   inteiro	
   e	
   o	
   segundo	
   for	
   ponto	
   flutuante	
  
(float/double)?	
  
Quando	
  um	
  operador	
  binário	
  é usado	
  com	
  operandos	
  numéricos	
  de	
  tipos	
  diferentes,	
  os	
  dados	
  são	
  
convertidos	
  para	
  um	
  tipo	
  comum	
  antes	
  do	
  operando	
  atuar,	
  e	
  o	
  resultado	
  será do	
  tipo	
  comum.	
  
As	
  regras	
  de	
  conversão	
  são	
  em	
  parte:	
  
Se	
   um	
   dos	
   operandos	
   for	
   do	
   tipo	
   double,	
   então	
   outro	
   operando	
   é	
   converttido	
   em	
   um	
   double,	
  
representando	
  o	
  mesmo	
  valor	
  numérico	
  (se	
  possível);	
  
Caso	
  contrário,	
  se	
  um	
  dos	
  operandos	
  for	
  do	
  tipo	
  float,	
  então	
  o	
  outro	
  operando	
  é	
  convertido	
  em	
  um	
  
float,	
  representando	
  o	
  mesmo	
  valor	
  numérico	
  (se	
  possível);	
  
Caso	
  contrário,	
  se	
  um	
  dos	
  operandos	
  for	
  do	
  tipo	
  unsigned	
  int,	
  então	
  o	
  outro	
  operando	
  é	
  convertido	
  
em	
  um	
  unsigned	
  int,	
  representando	
  o	
  mesmo	
  valor	
  numérico	
  (se	
  possível);	
  
	
  
	
  
 A	
  conversão	
  de	
  um	
  tipo	
  numérico	
  para	
  um	
  outro	
  também	
  ocorre	
  se	
  um	
  valor	
  de	
  um	
  tipo	
  é	
  atribuído	
  
a	
  um	
  identificaor	
  que	
  foi	
  declarado	
  para	
  armazenar	
  o	
  outro.	
  Esta	
  conversão	
  é	
  feita	
  sem	
  alterar	
  o	
  valor	
  
numérico,	
  se	
  possível.	
  Mas,	
  às	
  vezes,	
  é	
  impossível	
  converter	
  tipos	
  sem	
  uma	
  perda	
  de	
  informação.	
  
Teste	
  o	
  código	
  a	
  seguir:	
  
int main(void){ 
 double a = -1.8345; 
 float b = 1.0e16; 
 int c = -100; 
 unsigned int d = 10; 
 
 //Todas as seguintes atribuições resultam em uma alteração ou perda de informação 
 
 c = a; //double atribuido a um int -- fração perdida, c armazena -1 
 d = c; //inteiro negativo atribuído a um unsigned int -- problema 
 c = b; //um grande float atribuído a um int -- pode falhar 
}	
  
Quando	
  um	
  tipo	
  ponto	
  flutuante	
  é atribuído	
  a	
  um	
  inteiro,	
  a	
  parte	
  fracionária	
  é sempre	
  perdida	
  (não	
  
há arredondamentos	
  -­‐	
  a	
  parte	
  fracionária	
  é simplesmente	
  abandonada).	
  Se	
  o	
  valor	
  ponto	
  flutuante	
  é 
muito	
  grande	
  em	
  dimensão,	
  a	
  conversão	
  é indefinida.	
  
Quando	
  um	
  tipo	
  inteiro	
  é atribuído	
  a	
  um	
  tipo	
  ponto	
  flutuante,	
  o	
  resultado	
  é exato,	
  se	
  possível.	
  Caso	
  
contrário,	
  o	
  inteiro	
  é convertido	
  para	
  o	
  próximo	
  valor	
  ponto	
  flutuante	
  mais	
  baixo	
  ou	
  o	
  mais	
  alto;	
  
Cuidado	
   existem	
   conversões	
   problemáticas:	
   Quando	
   um	
   tipo	
   numérico	
   é passado	
   para	
   uma	
  
função	
  que	
  espera	
  um	
  tipo	
  numérico	
  diferente.	
  
	
  Conversões	
  de	
  um	
  tipo	
  de	
  dados	
  para	
  outro	
  também	
  podem	
  ser	
  controladas	
  explicitamente	
  usando	
  
o	
  operador	
  static_cast.	
  
A	
  expressão	
  
static_cast	
  <T>	
  (expressão)	
  
faz	
  com	
  que	
  expressão	
  seja	
  avaliada	
  e	
  que	
  o	
  valor	
  seja	
  convertido	
  para	
  o	
  tipo	
  T,	
  se	
  a	
  conversão	
  for	
  
definida.	
  
Teste:	
  
int main(void){ 
 int i = 1; 
 int j = 2; 
 double x = i/j; //x = 0 
 double y = static_cast <double>(i) / static_cast <double> (j); //y = 0.5 
double z = static_cast <double>(i) / j; //z = 0.5 
}	
  
ATIVIDADES	
   1. Escreva	
  um	
  programa	
  que	
  teste	
  o	
  tamanho	
  (Bytes)	
  e	
  os	
  limites	
  de	
  cada	
  tipo	
  numérico;	
  
2. Que	
  tipo	
  de	
  dados	
  você cogitaria	
  utilizar	
  para	
  armazenar	
  cada	
  uma	
  destas	
  quantidades?	
  
• O	
  número	
  de	
  quilowatts	
  usado	
  por	
  uma	
  fábrica;	
  
• O	
  número	
  de	
  parafusos	
  de	
  um	
  veículo	
  no	
  estoque;	
  
• A	
  massa	
  de	
  um	
  avião	
  de	
  87.000	
  quilogramas;	
  
3. Tempo	
  é representado	
  em	
  uma	
  simulação	
  com	
  i∆t,	
  onde	
  i	
  é inteiro.	
  Que	
  tipo	
  você usaria	
  para	
  i?	
  
Explique	
  brevemente.	
  
4. Dadas	
  as	
  seguintes	
  declarações,	
  identifique	
  o	
  tipo	
  de	
  cada	
  expressão:	
  
double	
  x	
  =	
  2.0;	
  
double	
  y=sqrt(x);	
  
int	
  j=2;	
  
int	
  j=sqrt(i);	
  
	
  
• x	
  +	
  i	
  
• x	
  *	
  y	
  +	
  i	
  
• j	
  /	
  i	
  
• i	
  /	
  x	
  
• j	
  -­‐	
  i 
	
  
	
  
ATIVIDADES	
  
AVALIATIVAS 
5. Escreva	
   um	
   programa	
   que	
   leia	
   uma	
   sequência	
   de	
   caracteres	
   e	
   escreva	
   a	
   mesma	
   aplicando	
   a	
  
seguinte	
  técnica	
  de	
  criptografia:	
  
char	
  digito;	
  
digito	
  =	
  ‘a’;	
  
char	
  digitoCriptografado;	
  
digitoCriptografado	
  =	
  digito	
  +	
  1;	
  
6. Escreva	
  um	
  programa	
  que	
  leia	
  um	
  número	
  inteiro	
  de	
  forma	
  robusta.	
  Isto	
  é,	
  o	
  programa	
  não	
  deve	
  
ser	
  abortado	
  diante	
  de	
  uma	
  entrada	
  inválida.	
  Exemplo:	
  Digitar	
  um	
  texto	
  onde	
  seria	
  esperado	
  um	
  
número.	
  Digitar	
  um	
  número	
  que	
  ultrapasse	
  a	
  capacidade	
  do	
  tipo	
  int.	
  
7. Faça	
  um	
  programa	
  que	
  leia	
  número	
  inteiro	
  não	
  negativo	
  (n)	
  e	
  calcule	
  seu	
  fatorial	
  (n!):	
  
n!	
  =	
  n*(n-­‐1)*(n-­‐2)*...*1	
  
n!	
  =	
  1	
  (para	
  n	
  =	
  0)	
  
8. Escreva	
  um	
  programaque	
  calcule	
  o	
  valor	
  da	
  constante	
  matemática	
  e:	
  
e	
  =	
  1	
  +	
  1/1!	
  +	
  1/2!	
  +	
  1/3!	
  +	
  ...	
  
9. Escreva	
  um	
  programa	
  que	
  calcule	
  o	
  valor	
  de	
  ex:	
  
ex	
  =	
  1	
  +	
  x/1!	
  +	
  x2/2!	
  +	
  x3/3!	
  +	
  ...	
  
Have	
  fun!