Tipos básicos

• Vimos dois tipos básicos da linguagem C: int e float
• Vamos agora introduzir mais tipos:
  • inteiros sem sinal
  • inteiros de tamanhos diferentes
  • números vírgula-flutuante de precisão dupla
  • carateres

Inteiros em C

• Os valores de tipo int têm sinal: podem ser negativos, positivos ou zero
• Usamos unsigned int para inteiros sem sinal: apenas positivos ou zero

        int i;          // com sinal
        unsigned int j; // sem sinal 

• Podemos abreviar a declaração para unsigned:

        unsigned j;      // unsigned int 

Inteiros com e sem sinal

• Tipicamente int e unsigned int são ambos representados por palavras de comprimento fixo
  • e.g. 16 ou 32 bits
• A linguagem C não especifica essa representação
• Os computadores usuais usam "complemento para dois" para representar valores com sinal
  • ver as aulas de IC

Exemplo: 16 bits sem sinal

\[ \begin{array}{ccc} \text{mínimo} & 0 & (0000000000000000)_2 \\ & 1 & (0000000000000001)_2 \\ & 2 & (0000000000000010)_2 \\ & \vdots & \vdots \\ \text{máximo} & {2^{16} -1} & (1111111111111111)_2 \end{array} \]

Exemplo: 16 bits com sinal

\[ \begin{array}{ccc} \text{mínimo} & {-2^{15}} & (1000000000000000)_2 \\ & \vdots & \vdots \\ & -1 & (1111111111111111)_2 \\ & 0 & (0000000000000000)_2 \\ & +1 & (0000000000000001)_2 \\ & \vdots & \vdots \\ \text{máximo} & {+2^{15} -1} & (0111111111111111)_2 \end{array} \]

Tamanhos

• O tipo int é tipicamente representado usando 32-bits (pode ser menor em CPUs de 8 e 16-bits)
• Podemos usar atributos long e short para especificar tamanhos maiores ou menores
• Juntamente com unsigned temos 6 tipos diferentes de inteiros:

   short int       unsigned short int
   int             unsigned int 
   long int        unsigned long int

• A ordem dos atributos não importa e podemos omitir o int

Tamanhos

• Sabemos que:
  
  short \(\leq\) int \(\leq\) long
  
  
• A linguagem C não especifica os limites exatos para os tamanhos
• Para cada implementação: o ficheiro "header" <limits.h> define os limites de cada tipo

Imprimir os limites

#include <stdio.h>
#include <limits.h>

int main(void) {
  printf("SHRT_MIN = %d\n", SHRT_MIN);
  printf("SHRT_MAX = %d\n", SHRT_MAX);

  printf("INT_MIN = %d\n", INT_MIN);
  printf("INT_MAX = %d\n", INT_MAX);

  printf("LONG_MIN = %ld\n", LONG_MIN);
  printf("LONG_MAX = %ld\n", LONG_MAX);
     // %ld para formatar long int
}

Exemplo

Execução no meu portátil (GNU/Linux X86-64):

$ ./tamanhos 
SHRT_MIN = -32768
SHRT_MAX = 32767
INT_MIN = -2147483648
INT_MAX = 2147483647
LONG_MIN = -9223372036854775808
LONG_MAX = 9223372036854775807

Constantes

• Constantes inteiras num programa são usualmente int
• Se o valor for demasiado grande então são long int
• Podemos especificar constantes long terminando com L ou l e unsigned com U ou u:

         17   // int
     -1000L   // long int 
     2500UL   // unsigned long int

• Se atribuirmos uma constante de tipo diferente da variável dá-se uma conversão implícita de tipo:

   long int i = 17;     // 17 -> 17L

Ler e escrever inteiros

Para ler ou escrever inteiros short, long ou unsigned devemos usar formatos específicos em scanf e printf.

Casos mais comuns:

"%u"

inteiro decimal unsigned

"%ld"

inteiro decimal long

"%lu"

inteiro decimal unsigned long

Exemplo

• O programa para calcular o volume de uma caixa (aula 2) usava int para as dimensões
• Introduzindo l = w = h = 1500 resulta em overflow (inteiros de 32-bits)
• Vamos modificar o programa:
  • primeiro para usar unsigned
  • depois para usar unsigned long

Versão 1

#include <stdio.h>

int main(void) {
   unsigned l, w, h, v;

   printf("L=?"); scanf("%u", &l);
   printf("W=?"); scanf("%u", &w);
   printf("H=?"); scanf("%u", &h);
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %u*%u*%u (cm)\n", l,w,h);
   printf("Volume: %u (cm^3)\n", v);
}

Execução 1

Esta versão calcula o volume correto para

l = w = h = 1500

mas obtemos de novo overflow para

l = w = h = 2000

Versão 2

#include <stdio.h>

int main(void) {
   unsigned long l, w, h, v;

   printf("L=?"); scanf("%lu", &l);
   printf("W=?"); scanf("%lu", &w);
   printf("H=?"); scanf("%lu", &h);
   v = l*w*h; // cálculo do volume

   printf("LxWxH: %lu*%lu*%lu (cm)\n", l,w,h);
   printf("Volume: %lu (cm^3)\n", v);
}

Execução 2

• Calcula resultado correto para l = w = h = 2000
• Exercício: descobrir os maiores valores l = w = h para os quais não ocorre overflow (assumindo unsigned long com 64-bits)

Vírgula flutuante

• Dois tipos básicos para vírgula flutuante:
  • float para precisão simples;
  • double para precisão dupla.
• O padrão da linguagem não define a precisão destes tipos
• As implementações modernas usualmente seguem um standard chamado IEEE 754

Limites IEEE 754

• double é usado para a maior parte das aplicações
• float é usando apenas se a precisão for pouco importante ou para poupar memória

Constantes

• Podemos escrever constantes virgula flutuante de várias formas:
  
  57.0 57. 57E0 5.7e1
  
  
• A constante tem uma mantissa e opcionalmente um expoente
• O expoente indica a potência de 10 que multiplica a mantissa e é prececedido da letra E (ou e)

Ler e escrever vírgula flutuante

• Devemos usar o formato "%lf" para ler valores double
• Mas: para imprimir float ou double devemos usar apenas "%f"
• Podemos também ainda usar "%g" para formatar usando notação científica

Exemplo

#include <stdio.h>

int main(void) {
  double l, w, h, v;

  printf("L=?"); scanf("%lf", &l);
  printf("W=?"); scanf("%lf", &w);
  printf("H=?"); scanf("%lf", &h);
  v = l*w*h; // cálculo do volume

  printf("LxWxH: %.3f*%.3f*%.3f (cm)\n", 
         l, w, h);
  printf("Volume: %.3g (cm^3)\n", v);
}

Conversões explícitas

Conversão explicita de tipos ("cast"):

• A expressão é calculada pelas regras usuais
• Usar parêntesis se necessário

int k = 2, n = 3; 
printf("%f\n", (float)k/(float)n); // 0.66666
printf("%f\n", (float)k/n);        // 0.66666
printf("%f\n", (float)(k/n));      // 0.00000

Conversões explícitas (cont.)

Também podemos converter entre tamanhos:

int i = 1500;
long j;
j = (long)i;

Devemos efetuar conversões antes de operações que possam causar overflow:

int i = 1500;
long j;
j = (long)(i*i*i);  // "overflow"(?)
j = (long)i*i*i;    // OK

Carateres

• O tipo char é usado para representar carateres
• Os carateres são representados pelo seu código numérico
• O padrão da linguagem não define a codificação
• O código mais comum é ASCII (American Standard Code for Information Interchange)
• O ASCII contém 128 símbolos e apenas as letras do alfabeto latino sem acentos
• O UTF-8 é uma extensão do ASCII que suporta outros alfabetos e acentos (e.g. português)
• Nestas aulas: vamos usar apenas ASCII simples (usar UTF-8 em C é mais difícil)

Carateres

• Uma variável de tipo char guarda um carater qualquer:

char ch;
ch = 'A';

• As constantes de carateres são delimitadas por aspas simples (não duplas):

'A'   // letra A maiúscula
'a'   // letra A minúscula
'?'   // sinal de pontuação
' '   // espaço

Códigos de carateres

• Carateres em C são tratados como inteiros "pequenos" (tipicamente 1 byte)
• Uma constante é simplemente o número correspondente ao código do carater
• Exemplos (em ASCII)

       'A'  // 65
       'a'  // 97
       ' '  // 32
       '0'  // 48

Operações sobre carateres

• Podemos efetuar operações aritméticas sobre carateres
• Correspondem a operações sobre os código numéricos associados
• Exemplos (assumindo ASCII):

int i;
char ch;

i = 'a';     // i é 97
ch = 65;     // c é código de 'A'
ch = ch + 1; // c é código de 'B'
ch ++;       // c é código de 'C'

Operações sobre carateres

• Podemos comparar carateres como quaisquer outros números
• Para que os programas sejam portáveis devemos usar constantes e não códigos concretos
• Exemplo: para testar se um carater está entre A e Z

• Os programas com constantes ficam também mais fáceis de ler

Sequências de escape

• Uma constante carater é normalmente apenas um símbolo entre aspas
• Alguns carateres especiais não podem ser escritos assim
• Para esse casos podemos usar sequências de escape
• Alguns exemplos:

• Delimitamos escapes com aspas simples; e.g.:
  char ch = '\n'; // mudança de linha

Imprimir e ler carateres

• Podemos usar o formato "%c" para ler ou escrever carateres usando scanf e printf

char ch;
scanf("%c", &ch);  // ler um carater
printf("%c", ch);  // escrever um carater

Exemplo

• Imprimir uma tabela dos carateres ASCII
• Imprimir cada carater com o seu código
• Apenas os carateres visíveis (entre 32 e 126)

Programa

#include <stdio.h>

int main(void) 
{
  char ch;

  for (ch = 32; ch<127; ch++) {
    if (ch % 8 == 0) {
      printf("\n"); /* mudar de linha */
    }
    printf("%3d: %c ", ch, ch);
  }
  printf("\n");
}

Tabela ASCII

 32:    33: !  34: "  35: #  36: $  37: %  38: &  39: ' 
 40: (  41: )  42: *  43: +  44: ,  45: -  46: .  47: / 
 48: 0  49: 1  50: 2  51: 3  52: 4  53: 5  54: 6  55: 7 
 56: 8  57: 9  58: :  59: ;  60: <  61: =  62: >  63: ? 
 64: @  65: A  66: B  67: C  68: D  69: E  70: F  71: G 
 72: H  73: I  74: J  75: K  76: L  77: M  78: N  79: O 
 80: P  81: Q  82: R  83: S  84: T  85: U  86: V  87: W 
 88: X  89: Y  90: Z  91: [  92: \  93: ]  94: ^  95: _ 
 96: `  97: a  98: b  99: c 100: d 101: e 102: f 103: g 
104: h 105: i 106: j 107: k 108: l 109: m 110: n 111: o 
112: p 113: q 114: r 115: s 116: t 117: u 118: v 119: w 
120: x 121: y 122: z 123: { 124: | 125: } 126: ~