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 complexo)

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: ~ 

Processar carateres

Ler e escrever

Podemos usar scanf() e printf() para ler e escrever carateres.

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

Mas é mais comum usar as funções mais básicas:

  ch = getchar(); // ler um carater
  putchar(ch);    // escrever um carater

Reservamos scanf() e printf() para leitura e escrita formatada (e.g. números).

Ler carateres

   int getchar(void);

• Consome o próximo carater da entrada-padrão e retorna o seu código numérico
• Se não há mais carateres retorna EOF (end-of-file)
  • constante definida em stdio.h (tipicamente -1)
  • no terminal: Control-D sinaliza o fim da entrada
• O resultado é um int e não um char
• Geralmente será um inteiro “pequeno” (o código de um carater)

Exemplo

Contar o número de linhas na entrada padrão.

#include <stdio.h>

int main(void) {
    int ch;    // código de um carater
    int lines = 0;  // número de linhas
    do {
        ch = getchar();  // ler um carater
        if(ch == '\n')   // nova linha?
            lines ++;
    } while(ch != EOF);
    printf("%d linhas\n", lines);
}

Exemplo (2)

Versão mais “idiomática”: leitura do próximo carater na condição do ciclo.

#include <stdio.h>

int main(void) {
    int ch;    // código de um carater
    int lines = 0;  // número de linhas
    while ((ch=getchar()) != EOF) {
      if(ch == '\n')  // nova linha?
         lines++;
    }
    printf("%d linhas\n", lines);
}

Funções de biblioteca

• A biblioteca de C inclui algumas funções pré-definidas para manipulação de carateres:
  • testar se um carater é letra maiúscula letra minúscula, algarismo, etc.
  • converter letras minúsculas para maiúsculas e vice-versa
• São definições simples mas frequentemente usadas

Algumas funções

#include <ctype.h>
  
int islower(int ch);  // letra minúscula a..z
int isupper(int ch);  // letra maiúscula A..Z
int isalpha(int ch);  // a..z ou A..Z
int isdigit(int ch);  // algarimo decimal 0..9

int tolower(int ch); // converter em minúscula
int toupper(int ch); // converter em maiúscula

Atenção: apenas funcionam para ASCII simples — e.g. letras sem acentos.

Algumas funções

• Devemos incluir o header <ctype.h>
• As funções isXXXXX(ch) testam se o carater ch pertence a uma classe
  • resultado 1 em caso afirmativo e 0 em caso negativo
• As funções toXXXXX(ch) transformam o carater ch

Exemplo: contar letras e algarismos

#include <stdio.h>
#include <ctype.h>

int main(void) {
  int ch;
  int letras = 0, algarismos = 0;

  while((ch=getchar()) != EOF) {
    if (isalpha(ch))
       letras++;
    else if(isdigit(ch))
       algarismos++;
  }
  printf("%d, %d\n", letras, algarismos);
}

Instrução switch

Instrução switch

Podemos usar uma sequência de if/else para escolher entre múltiplos casos:

if(nota == 4)
  printf("Excelente");
else if(nota == 3)
  printf("Bom");
else if(nota == 2)
  printf("Razoável");
else if(nota == 1)
  printf("Fraco");
else
  printf("Nota inválida");

Instrução switch

Em alternativa, podemos usar uma instrução switch:

switch(nota) {
  case 4:  printf("Excelente");
           break;
  case 3:  printf("Bom");
           break;
  case 2:  printf("Razoável");
           break;
  case 1:  printf("Fraco");
           break;
  default: printf("Nota inválida");
           break;
}

Instrução switch

• A instrução switch pode ser mais legível que a sequência if/else if equivalente
• Poderá também executar mais eficientemente
• Forma geral:

  switch ( expressão ) {
    case constante1: instruções
    ...
    case constanteN: instruções 

    default: instruções 
  }

Instrução switch

• A expressão escrutinada deve ser de tipo inteiro
  • e.g. int, unsigned int, long, char
• Carateres são também inteiros em C
• Não pode ser vírgula-flutuante (float, double) ou texto (strings)
• Podemos usar expressões no case desde que sejam constantes, e.g.

   case 33:  ...
   case 'A': ...
   case (100-1)/2: ...

Instrução switch

• Após cada case segue-se uma sequência de instruções
• A última instrução de cada sequência é normalmente break
• Não são necessárias chavetas
• Não podemos repetir casos
• A ordem dos case não importa se colocarmos sempre o break

Instrução switch

Podemos agrupar multiplos case com uma só sequência de instruções:

switch(nota) {
  case 4:
  case 3:
  case 2: printf("Aprovado");
          break;
  case 1: printf("Reprovado");
          break;
  default: printf("Nota inválida");
           break;
}

Instrução switch

Podemos escrever de forma mais sucinta juntando vários case.

switch(nota) {
  case 4: case 3: case 2: 
          printf("Aprovado");
          break;
  case 1: printf("Reprovado");
          break;
  default: printf("Nota inválida");
           break;
}

Efeito do break

• O break faz com que execução continue na instrução seguinte ao switch
• Se omitirmos o break, a execução continua no caso seguinte

Efeito do break

switch(nota) {
  case 4:  printf("Excelente");
  case 3:  printf("Bom");
  case 2:  printf("Razoável");
  case 1:  printf("Fraco");
  default: printf("Nota inválida");
}

Se a nota for 3, imprime

BomRazoávelFracoNota inválida

Exemplo: contar vogais e consoantes

• Ler um texto e contar o número de vogais e consoantes
• Convertemos cada letra para maiúscula
  • fica igual se não for letra
• Usamos switch para distingir:
  • 5 casos para as vogais (A, E, I, O, U)
  • se não é vogal e for letra, então tem de ser consoante

#include <stdio.h>
#include <ctype.h>

int main(void) {
  int ch, vogais = 0, consoantes = 0;
  while ((ch=getchar()) != EOF) {
    ch = toupper(ch);
    switch (ch) {
    case 'A': case 'E': 
    case 'I': case 'O': case 'U':
        vogais ++;
        break;
    default:
        if(isalpha(ch)) consoantes ++;
    }
  }
  printf("%d, %d\n", vogais, consoantes);
}

Execução

$ cat texto2.txt
"To be or not to be; that is the question."
    -- W. SHAKESPEARE

$ gcc -o letras letras.c
$ ./letras < texto2.txt
18 vogais, 24 consoantes