Programação Imperativa. Lição n.º 17 Cadeias de carateres

Transcrição

1 Programação Imperativa Lição n.º 17 Cadeias de carateres

2 Cadeias de carateres Conceitos básicos. Técnicas elementares. Arrays de cadeias de carateres. 11/20/16 Programação Imperativa 2

3 Cadeias de carateres As cadeias de carateres são arrays de char. Cada valor de tipo char ocupa um byte. As cadeias de carateres são representadas em memória por sequências de bytes. Os valores numéricos dos bytes vão de 0 a 255 ou de -128 a 127. Nas cadeias de carateres, o byte de valor numérico zero é o terminador: assinala o fim da cadeia. As funções que processam cadeias de carateres ignoram o que está para além do terminador. As funções que criam cadeias de carateres inserem o terminador após os carateres visíveis. 11/20/16 Programação Imperativa 3

4 Exemplo: Hello Um programa que ciclicamente aceita um nome e responde com Hello seguido do nome lido: void hello(const char *s) printf("hello %s\n", s); void test_hello(void) char name[16]; $./a.out Pedro Hello Pedro Nobody Hello Nobody Cristiano Ronaldo Hello Cristiano Hello Ronaldo Monster Hello Monster $ while (scanf("%s", name)!= EOF) hello(name); Se introduzirmos um nome com mais de 15 carateres, causaremos buffer overflow... Note bem: ao ler cadeias, não se usa o &. 11/20/16 Programação Imperativa 4

5 Cadeias na memória Observemos a pilha, à entrada da função hello: A variável s (a amarelo) na frame da função hello, contém o endereço da variável name (a verde) na frame da função test_hello. A cadeia Cristiano está na variável name, a qual ocupa 16 bytes. O byte 00 a seguir ao byte 6F é o terminador. 11/20/16 Programação Imperativa 5

6 Contagem de carateres Quantas vezes um dado caráter ocorre numa cadeia? int str_count(const char* s, char x) int result = 0; for (int i = 0; s[i]!= '\0'; i++) if (s[i] == x) result++; return result; void unit_test_str_count(void) assert(str_count("malmequer", 'm') == 2); assert(str_count("indelevelmente", 'e') == 5); assert(str_count("paralelipidedo", 'u') == 0); 11/20/16 Programação Imperativa 6

7 Exemplo: robô Um robô desloca-se num plano, recebendo comandos para indicar o sentido do movimento: com E vai para Este, com N vai para Norte, com W vai para Oeste e com S vai para Sul. Um comando é uma cadeia formada só pelas letras E, N, W e S. O robô parte da posição <0, 0>. Depois de uma sequência de comandos, lidos da consola, onde é que está o robô? 11/20/16 Programação Imperativa 7

8 Programa do robô Observe: void test_robot(void) int x = 0; int y = 0; char s[2000]; while (scanf("%s", s)!= EOF) int ne = str_count(s, 'E'); int nn = str_count(s, 'N'); int nw = str_count(s, 'W'); int ns = str_count(s, 'S'); x += ne - nw; y += nn - ns; printf("%d %d\n", x, y); $./a.out NNNNSWWWWSEEWWWWWNNNNNN -7 8 $ /a.out NN SS WW EENNNNSSSWWE -1 1 $ 11/20/16 Programação Imperativa 8

9 Transformação char* int* Os carateres são, na realidade, números inteiros, mas que ocupam só 8 bits. A conversão char int é automática. Eis, como exemplo, uma função que transforma um array de chars num array de ints equivalente : int ints_from_string(const char *s, int *a) int result = 0; for (int i = 0; s[i]!= '\0'; i++) a[result++] = s[i]; return result; 11/20/16 Programação Imperativa 9

10 Testando a transformação char* int* Eis uma função de teste que repetidamente lê uma cadeia, mostra-a e depois calcula e mostra o array de ints equivalente: void test_ints_from_string(void) char s[2000]; while (scanf("%s", s)!= EOF) printf("%s\n", s); int a[2000]; int n = ints_from_string(s, a); ints_println_basic(a, n); $./a.out FARO FARO LISBOA LISBOA lisboa lisboa MONTE GORDO MONTE GORDO /20/16 Programação Imperativa 10

11 Transformação int* char* É parecido, mas atenção: void str_from_ints(int *a, int n, char *s) for (int i = 0; i < n; i++) s[i] = a[i]; s[n] = '\0'; Não podemos esquecer de acrescentar o terminador. void test_str_from_ints(void) int a[2000]; int n = ints_get(a); char s[2001]; str_from_ints(a, n, s); printf("%s\n", s); $./a.out AZP $./a.out lisboa $./a.out $./a.out !"#$%[\ $ 11/20/16 Programação Imperativa 11

12 Cadeias numéricas Numa cadeia numérica, todos os caracteres são algarismos. Faz sentido obter diretamente o array dos números correspondentes: int ints_from_numeric(const char *s, int *a) int result = 0; for (int i = 0; s[i]!= '\0'; i++) a[result++] = s[i] - '0'; return result; Note bem: '\0' é o número 0 (zero); '0' é o número 48, código do caractere ZERO. $./a.out void test_ints_from_numeric(void) char s[2000]; while (scanf("%s", s)!= EOF) printf("%s\n", s); int a[2000]; int n = ints_from_numeric(s, a); ints_println_basic(a, n); /20/16 Programação Imperativa 12

13 Igualdade de cadeias Para verificar se duas cadeias, s e r, são iguais, NÃO se escreve s == r. Escreve-se strcmp(s, r) == 0. Para verificar se são diferentes, escreve-se strcmp(s, r)!= 0. A função strcmp é a função de comparação de cadeias e pertence à biblioteca do C. Para usá-la, devemos fazer #include <string.h>. 11/20/16 Programação Imperativa 13

14 Problema do apuramento de votos Temos as contagem das mesas de votos reunidos num ficheiro, como o ilustrado aqui ao lado. Queremos apurar os resultados de cada partido, mostrando-os no final pela ordem PAF, PS, CDU, BE. Vamos processar diretamente o ficheiro, usando quatro variáveis de acumulação, lendo cada par cadeiavalor e adicionando o valor à variável respetiva. PAF 9 PS 6 CDU 4 BE 2 PS 10 PAF 8 BE 5 CDU 4 PAF 11 PS 5 PS 8 PAF 4 CDU 2 11/20/16 Programação Imperativa 14

15 Programa do apuramento dos votos Observe: void do_count_votes(void) int paf = 0; int ps = 0; int cdu = 0; int be = 0; char s[8]; int x; while (scanf("%s%d", s, &x)!= EOF) if (strcmp(s, "PAF") == 0) paf += x; else if (strcmp(s, "PS") == 0) ps += x; else if (strcmp(s, "CDU") == 0) cdu += x; else if (strcmp(s, "BE") == 0) be += x; else assert(0); printf("%d %d %d %d\n", paf, ps, cdu, be); Esta técnica não é lá muito prática se houver muitos partidos... $./a.out < votes_01.txt $ a.out PAF 10 CDU 5 PAF 7 PS 12 CDU $ 11/20/16 Programação Imperativa 15

16 Arrays de cadeias de carateres Normalmente usaremos apenas arrays de cadeias dinâmicas, e, ocasionalmente, arrays de cadeias estáticas. As cadeias dinâmicas são criadas com malloc. Cada valor no array de cadeias dinâmicas contém o endereço de uma cadeia, a qual reside na memória dinâmica. O valor da cadeia na memória dinâmica terá sido copiado a partir de uma cadeia na pilha. Tecnicamente, um array de cadeias dinâmicas é um array de apontadores, isto é, um array cujos valores são endereços. Nos usos mais comuns, as cadeias dinâmicas são referenciadas por variáveis que estão na pilha. Note bem: dizemos cadeias dinâmicas porque elas residem na memória dinâmica (ou seja, no heap), não porque elas tenham algum tipo de dinamismo. 11/20/16 Programação Imperativa 16

17 Exemplo: Hello para muitos Um programa que aceita uma sequência de nomes, até ao fim dos dados, e depois diz Hello com cada um dos nomes lidos. void test_hello_many(void) char *names[10]; int n = 0; char word[16]; while (scanf("%s", word)!= EOF) names[n] = (char *) malloc(strlen(word) + 1); strcpy(names[n++], word); for (int i = 0; i < n; i++) hello(names[i]); $./a.out Cristiano Rui Ricardo William Rafael Hello Cristiano Hello Rui Hello Ricardo Hello William Hello Rafael $ 11/20/16 Programação Imperativa 17

18 strlen A função strlen dá o comprimento da cadeia passada em argumento: void unit_test_strlen(void) char *s1 = "guatemala"; assert(strlen(s1) == 9); assert(strlen(s1+4) == 5); assert(strlen(s1+9) == 0); char *s2 = "brasil"; assert(strlen(s2) == 6); assert(strlen(s2+1) == 5); Podia programar-se assim: int str_len(const char *s) int result = 0; while (s[result]!= '\0') result++; return result; Note que s1+4, por exemplo, é a subcadeia de s1 que começa em s[4]. Na verdade, o tipo do resultado da função de biblioteca strlen não é int, mas sim size_t, o que por vezes causa algumas surpresas. Note bem: representamos por '\0' o caráter cujo valor numérico é 0 (o tal que é usado como terminador nas cadeias). 11/20/16 Programação Imperativa 18

19 strcpy Para copiar os bytes que constituem uma cadeia para outra posição de memória, usamos a função strcpy. Podia programar-se assim: void str_cpy(char *s, const char *t) int i = 0; while (t[i]!= 0) s[i] = t[i]; i++; s[i] = '\0'; Note que todos os carateres de t são copiados para posições sucessivas, a partir da primeira posição s, e depois, no fim, acrescenta-se o terminador. Na verdade, a função de biblioteca strcpy retorna o valor do primeiro argumento, que representa o endereço para onde o segundo argumento terá sido copiado. Quase sempre ignoramos o valor de retorno. 11/20/16 Programação Imperativa 19

20 Hello para muitos: pilha Nesta experiência entrámos os nomes de cinco países: dinamarca, mali, uruguai, angola e china. Na pilha, a amarelo, a variável s; a vermelho, a variável n, com valor 5; a verde, a variável word, que contém china ; a azul, o array names. No array names, cada valor ocupa 8 bytes; os 5 primeiros representam endereços no heap; os outros não estão inicializados. O valor em s é igual ao primeiro valor em names. dinamarca mali uruguai angola china 11/20/16 Programação Imperativa 20

21 Hello para muitos: heap Os nomes dos países estarão no heap, referenciados pelos endereços no array names: dinamarca mali uruguai angola china Curiosamente, nesta experiência angola foi parar a outra zona do heap: 11/20/16 Programação Imperativa 21

22 Argumentos de tipo array Observámos que o valor do argumento s, à entrada da função hello contém o endereço de cadeia que foi passada. Note muito bem: é o endereço da cadeia, não os carateres que compõem a cadeia; estes ficam onde estavam. No exemplo test_hello, esses carateres estavam na pilha; no exemplo test_hello_many, estavam no heap. Recorde que quando o argumento é um número, a variável que representa o argumento contém uma cópia do valor argumento. Isto é uma regra geral: se o argumento é um número, o seu valor residirá numa posição de memória na frame da função chamada; se o argumento é um array, a frame da função chamada registará o endereço do array. Na situação registada na página anterior, tratando-se da primeira chamada da função hello, o argumento tem o valor do endereço da primeira cadeira, no heap: B0. A seguir terá os valores dos endereças outras cadeias no array: C0, D0, , E0. 11/20/16 Programação Imperativa 22